


var asmCrypto = (function (exports) {
    'use strict';

    var local_atob = typeof atob === 'undefined' ? function (str) { return Buffer.from(str, 'base64').toString('binary'); } : atob;
    var local_btoa = typeof btoa === 'undefined' ? function (str) { return Buffer.from(str, 'binary').toString('base64'); } : btoa;
    function string_to_bytes(str, utf8) {
        if (utf8 === void 0) { utf8 = false; }
        var len = str.length, bytes = new Uint8Array(utf8 ? 4 * len : len);
        for (var i = 0, j = 0; i < len; i++) {
            var c = str.charCodeAt(i);
            if (utf8 && 0xd800 <= c && c <= 0xdbff) {
                if (++i >= len)
                    throw new Error('Malformed string, low surrogate expected at position ' + i);
                c = ((c ^ 0xd800) << 10) | 0x10000 | (str.charCodeAt(i) ^ 0xdc00);
            }
            else if (!utf8 && c >>> 8) {
                throw new Error('Wide characters are not allowed.');
            }
            if (!utf8 || c <= 0x7f) {
                bytes[j++] = c;
            }
            else if (c <= 0x7ff) {
                bytes[j++] = 0xc0 | (c >> 6);
                bytes[j++] = 0x80 | (c & 0x3f);
            }
            else if (c <= 0xffff) {
                bytes[j++] = 0xe0 | (c >> 12);
                bytes[j++] = 0x80 | ((c >> 6) & 0x3f);
                bytes[j++] = 0x80 | (c & 0x3f);
            }
            else {
                bytes[j++] = 0xf0 | (c >> 18);
                bytes[j++] = 0x80 | ((c >> 12) & 0x3f);
                bytes[j++] = 0x80 | ((c >> 6) & 0x3f);
                bytes[j++] = 0x80 | (c & 0x3f);
            }
        }
        return bytes.subarray(0, j);
    }
    function hex_to_bytes(str) {
        var len = str.length;
        if (len & 1) {
            str = '0' + str;
            len++;
        }
        var bytes = new Uint8Array(len >> 1);
        for (var i = 0; i < len; i += 2) {
            bytes[i >> 1] = parseInt(str.substr(i, 2), 16);
        }
        return bytes;
    }
    function base64_to_bytes(str) {
        return string_to_bytes(local_atob(str));
    }
    function bytes_to_string(bytes, utf8) {
        if (utf8 === void 0) { utf8 = false; }
        var len = bytes.length, chars = new Array(len);
        for (var i = 0, j = 0; i < len; i++) {
            var b = bytes[i];
            if (!utf8 || b < 128) {
                chars[j++] = b;
            }
            else if (b >= 192 && b < 224 && i + 1 < len) {
                chars[j++] = ((b & 0x1f) << 6) | (bytes[++i] & 0x3f);
            }
            else if (b >= 224 && b < 240 && i + 2 < len) {
                chars[j++] = ((b & 0xf) << 12) | ((bytes[++i] & 0x3f) << 6) | (bytes[++i] & 0x3f);
            }
            else if (b >= 240 && b < 248 && i + 3 < len) {
                var c = ((b & 7) << 18) | ((bytes[++i] & 0x3f) << 12) | ((bytes[++i] & 0x3f) << 6) | (bytes[++i] & 0x3f);
                if (c <= 0xffff) {
                    chars[j++] = c;
                }
                else {
                    c ^= 0x10000;
                    chars[j++] = 0xd800 | (c >> 10);
                    chars[j++] = 0xdc00 | (c & 0x3ff);
                }
            }
            else {
                throw new Error('Malformed UTF8 character at byte offset ' + i);
            }
        }
        var str = '', bs = 16384;
        for (var i = 0; i < j; i += bs) {
            str += String.fromCharCode.apply(String, chars.slice(i, i + bs <= j ? i + bs : j));
        }
        return str;
    }
    function bytes_to_hex(arr) {
        var str = '';
        for (var i = 0; i < arr.length; i++) {
            var h = (arr[i] & 0xff).toString(16);
            if (h.length < 2)
                str += '0';
            str += h;
        }
        return str;
    }
    function bytes_to_base64(arr) {
        return local_btoa(bytes_to_string(arr));
    }
    function is_bytes(a) {
        return a instanceof Uint8Array;
    }
    function _heap_init(heap, heapSize) {
        var size = heap ? heap.byteLength : heapSize || 65536;
        if (size & 0xfff || size <= 0)
            throw new Error('heap size must be a positive integer and a multiple of 4096');
        heap = heap || new Uint8Array(new ArrayBuffer(size));
        return heap;
    }
    function _heap_write(heap, hpos, data, dpos, dlen) {
        var hlen = heap.length - hpos;
        var wlen = hlen < dlen ? hlen : dlen;
        heap.set(data.subarray(dpos, dpos + wlen), hpos);
        return wlen;
    }
    function joinBytes() {
        var arg = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            arg[_i] = arguments[_i];
        }
        var totalLenght = arg.reduce(function (sum, curr) { return sum + curr.length; }, 0);
        var ret = new Uint8Array(totalLenght);
        var cursor = 0;
        for (var i = 0; i < arg.length; i++) {
            ret.set(arg[i], cursor);
            cursor += arg[i].length;
        }
        return ret;
    }

    /**
     * Util exports
     */

    var __extends = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var IllegalStateError = /** @class */ (function (_super) {
        __extends(IllegalStateError, _super);
        function IllegalStateError() {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var _this = _super.apply(this, args) || this;
            return _this;
        }
        return IllegalStateError;
    }(Error));
    var IllegalArgumentError = /** @class */ (function (_super) {
        __extends(IllegalArgumentError, _super);
        function IllegalArgumentError() {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var _this = _super.apply(this, args) || this;
            return _this;
        }
        return IllegalArgumentError;
    }(Error));
    var SecurityError = /** @class */ (function (_super) {
        __extends(SecurityError, _super);
        function SecurityError() {
            var args = [];
            for (var _i = 0; _i < arguments.length; _i++) {
                args[_i] = arguments[_i];
            }
            var _this = _super.apply(this, args) || this;
            return _this;
        }
        return SecurityError;
    }(Error));

    /**
     * @file {@link http://asmjs.org Asm.js} implementation of the {@link https://en.wikipedia.org/wiki/Advanced_Encryption_Standard Advanced Encryption Standard}.
     * @author Artem S Vybornov <vybornov@gmail.com>
     * @license MIT
     */
    var AES_asm = function () {

      /**
       * Galois Field stuff init flag
       */
      var ginit_done = false;

      /**
       * Galois Field exponentiation and logarithm tables for 3 (the generator)
       */
      var gexp3, glog3;

      /**
       * Init Galois Field tables
       */
      function ginit() {
        gexp3 = [],
          glog3 = [];

        var a = 1, c, d;
        for (c = 0; c < 255; c++) {
          gexp3[c] = a;

          // Multiply by three
          d = a & 0x80, a <<= 1, a &= 255;
          if (d === 0x80) a ^= 0x1b;
          a ^= gexp3[c];

          // Set the log table value
          glog3[gexp3[c]] = c;
        }
        gexp3[255] = gexp3[0];
        glog3[0] = 0;

        ginit_done = true;
      }

      /**
       * Galois Field multiplication
       * @param {number} a
       * @param {number} b
       * @return {number}
       */
      function gmul(a, b) {
        var c = gexp3[(glog3[a] + glog3[b]) % 255];
        if (a === 0 || b === 0) c = 0;
        return c;
      }

      /**
       * Galois Field reciprocal
       * @param {number} a
       * @return {number}
       */
      function ginv(a) {
        var i = gexp3[255 - glog3[a]];
        if (a === 0) i = 0;
        return i;
      }

      /**
       * AES stuff init flag
       */
      var aes_init_done = false;

      /**
       * Encryption, Decryption, S-Box and KeyTransform tables
       *
       * @type {number[]}
       */
      var aes_sbox;

      /**
       * @type {number[]}
       */
      var aes_sinv;

      /**
       * @type {number[][]}
       */
      var aes_enc;

      /**
       * @type {number[][]}
       */
      var aes_dec;

      /**
       * Init AES tables
       */
      function aes_init() {
        if (!ginit_done) ginit();

        // Calculates AES S-Box value
        function _s(a) {
          var c, s, x;
          s = x = ginv(a);
          for (c = 0; c < 4; c++) {
            s = ((s << 1) | (s >>> 7)) & 255;
            x ^= s;
          }
          x ^= 99;
          return x;
        }

        // Tables
        aes_sbox = [],
          aes_sinv = [],
          aes_enc = [[], [], [], []],
          aes_dec = [[], [], [], []];

        for (var i = 0; i < 256; i++) {
          var s = _s(i);

          // S-Box and its inverse
          aes_sbox[i] = s;
          aes_sinv[s] = i;

          // Ecryption and Decryption tables
          aes_enc[0][i] = (gmul(2, s) << 24) | (s << 16) | (s << 8) | gmul(3, s);
          aes_dec[0][s] = (gmul(14, i) << 24) | (gmul(9, i) << 16) | (gmul(13, i) << 8) | gmul(11, i);
          // Rotate tables
          for (var t = 1; t < 4; t++) {
            aes_enc[t][i] = (aes_enc[t - 1][i] >>> 8) | (aes_enc[t - 1][i] << 24);
            aes_dec[t][s] = (aes_dec[t - 1][s] >>> 8) | (aes_dec[t - 1][s] << 24);
          }
        }

        aes_init_done = true;
      }

      /**
       * Asm.js module constructor.
       *
       * <p>
       * Heap buffer layout by offset:
       * <pre>
       * 0x0000   encryption key schedule
       * 0x0400   decryption key schedule
       * 0x0800   sbox
       * 0x0c00   inv sbox
       * 0x1000   encryption tables
       * 0x2000   decryption tables
       * 0x3000   reserved (future GCM multiplication lookup table)
       * 0x4000   data
       * </pre>
       * Don't touch anything before <code>0x400</code>.
       * </p>
       *
       * @alias AES_asm
       * @class
       * @param foreign - <i>ignored</i>
       * @param buffer - heap buffer to link with
       */
      var wrapper = function (foreign, buffer) {
        // Init AES stuff for the first time
        if (!aes_init_done) aes_init();

        // Fill up AES tables
        var heap = new Uint32Array(buffer);
        heap.set(aes_sbox, 0x0800 >> 2);
        heap.set(aes_sinv, 0x0c00 >> 2);
        for (var i = 0; i < 4; i++) {
          heap.set(aes_enc[i], (0x1000 + 0x400 * i) >> 2);
          heap.set(aes_dec[i], (0x2000 + 0x400 * i) >> 2);
        }

        /**
         * Calculate AES key schedules.
         * @instance
         * @memberof AES_asm
         * @param {number} ks - key size, 4/6/8 (for 128/192/256-bit key correspondingly)
         * @param {number} k0 - key vector components
         * @param {number} k1 - key vector components
         * @param {number} k2 - key vector components
         * @param {number} k3 - key vector components
         * @param {number} k4 - key vector components
         * @param {number} k5 - key vector components
         * @param {number} k6 - key vector components
         * @param {number} k7 - key vector components
         */
        function set_key(ks, k0, k1, k2, k3, k4, k5, k6, k7) {
          var ekeys = heap.subarray(0x000, 60),
            dkeys = heap.subarray(0x100, 0x100 + 60);

          // Encryption key schedule
          ekeys.set([k0, k1, k2, k3, k4, k5, k6, k7]);
          for (var i = ks, rcon = 1; i < 4 * ks + 28; i++) {
            var k = ekeys[i - 1];
            if ((i % ks === 0) || (ks === 8 && i % ks === 4)) {
              k = aes_sbox[k >>> 24] << 24 ^ aes_sbox[k >>> 16 & 255] << 16 ^ aes_sbox[k >>> 8 & 255] << 8 ^ aes_sbox[k & 255];
            }
            if (i % ks === 0) {
              k = (k << 8) ^ (k >>> 24) ^ (rcon << 24);
              rcon = (rcon << 1) ^ ((rcon & 0x80) ? 0x1b : 0);
            }
            ekeys[i] = ekeys[i - ks] ^ k;
          }

          // Decryption key schedule
          for (var j = 0; j < i; j += 4) {
            for (var jj = 0; jj < 4; jj++) {
              var k = ekeys[i - (4 + j) + (4 - jj) % 4];
              if (j < 4 || j >= i - 4) {
                dkeys[j + jj] = k;
              } else {
                dkeys[j + jj] = aes_dec[0][aes_sbox[k >>> 24]]
                  ^ aes_dec[1][aes_sbox[k >>> 16 & 255]]
                  ^ aes_dec[2][aes_sbox[k >>> 8 & 255]]
                  ^ aes_dec[3][aes_sbox[k & 255]];
              }
            }
          }

          // Set rounds number
          asm.set_rounds(ks + 5);
        }

        // create library object with necessary properties
        var stdlib = {Uint8Array: Uint8Array, Uint32Array: Uint32Array};

        var asm = function (stdlib, foreign, buffer) {
          "use asm";

          var S0 = 0, S1 = 0, S2 = 0, S3 = 0,
            I0 = 0, I1 = 0, I2 = 0, I3 = 0,
            N0 = 0, N1 = 0, N2 = 0, N3 = 0,
            M0 = 0, M1 = 0, M2 = 0, M3 = 0,
            H0 = 0, H1 = 0, H2 = 0, H3 = 0,
            R = 0;

          var HEAP = new stdlib.Uint32Array(buffer),
            DATA = new stdlib.Uint8Array(buffer);

          /**
           * AES core
           * @param {number} k - precomputed key schedule offset
           * @param {number} s - precomputed sbox table offset
           * @param {number} t - precomputed round table offset
           * @param {number} r - number of inner rounds to perform
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _core(k, s, t, r, x0, x1, x2, x3) {
            k = k | 0;
            s = s | 0;
            t = t | 0;
            r = r | 0;
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            var t1 = 0, t2 = 0, t3 = 0,
              y0 = 0, y1 = 0, y2 = 0, y3 = 0,
              i = 0;

            t1 = t | 0x400, t2 = t | 0x800, t3 = t | 0xc00;

            // round 0
            x0 = x0 ^ HEAP[(k | 0) >> 2],
              x1 = x1 ^ HEAP[(k | 4) >> 2],
              x2 = x2 ^ HEAP[(k | 8) >> 2],
              x3 = x3 ^ HEAP[(k | 12) >> 2];

            // round 1..r
            for (i = 16; (i | 0) <= (r << 4); i = (i + 16) | 0) {
              y0 = HEAP[(t | x0 >> 22 & 1020) >> 2] ^ HEAP[(t1 | x1 >> 14 & 1020) >> 2] ^ HEAP[(t2 | x2 >> 6 & 1020) >> 2] ^ HEAP[(t3 | x3 << 2 & 1020) >> 2] ^ HEAP[(k | i | 0) >> 2],
                y1 = HEAP[(t | x1 >> 22 & 1020) >> 2] ^ HEAP[(t1 | x2 >> 14 & 1020) >> 2] ^ HEAP[(t2 | x3 >> 6 & 1020) >> 2] ^ HEAP[(t3 | x0 << 2 & 1020) >> 2] ^ HEAP[(k | i | 4) >> 2],
                y2 = HEAP[(t | x2 >> 22 & 1020) >> 2] ^ HEAP[(t1 | x3 >> 14 & 1020) >> 2] ^ HEAP[(t2 | x0 >> 6 & 1020) >> 2] ^ HEAP[(t3 | x1 << 2 & 1020) >> 2] ^ HEAP[(k | i | 8) >> 2],
                y3 = HEAP[(t | x3 >> 22 & 1020) >> 2] ^ HEAP[(t1 | x0 >> 14 & 1020) >> 2] ^ HEAP[(t2 | x1 >> 6 & 1020) >> 2] ^ HEAP[(t3 | x2 << 2 & 1020) >> 2] ^ HEAP[(k | i | 12) >> 2];
              x0 = y0, x1 = y1, x2 = y2, x3 = y3;
            }

            // final round
            S0 = HEAP[(s | x0 >> 22 & 1020) >> 2] << 24 ^ HEAP[(s | x1 >> 14 & 1020) >> 2] << 16 ^ HEAP[(s | x2 >> 6 & 1020) >> 2] << 8 ^ HEAP[(s | x3 << 2 & 1020) >> 2] ^ HEAP[(k | i | 0) >> 2],
              S1 = HEAP[(s | x1 >> 22 & 1020) >> 2] << 24 ^ HEAP[(s | x2 >> 14 & 1020) >> 2] << 16 ^ HEAP[(s | x3 >> 6 & 1020) >> 2] << 8 ^ HEAP[(s | x0 << 2 & 1020) >> 2] ^ HEAP[(k | i | 4) >> 2],
              S2 = HEAP[(s | x2 >> 22 & 1020) >> 2] << 24 ^ HEAP[(s | x3 >> 14 & 1020) >> 2] << 16 ^ HEAP[(s | x0 >> 6 & 1020) >> 2] << 8 ^ HEAP[(s | x1 << 2 & 1020) >> 2] ^ HEAP[(k | i | 8) >> 2],
              S3 = HEAP[(s | x3 >> 22 & 1020) >> 2] << 24 ^ HEAP[(s | x0 >> 14 & 1020) >> 2] << 16 ^ HEAP[(s | x1 >> 6 & 1020) >> 2] << 8 ^ HEAP[(s | x2 << 2 & 1020) >> 2] ^ HEAP[(k | i | 12) >> 2];
          }

          /**
           * ECB mode encryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _ecb_enc(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            _core(
              0x0000, 0x0800, 0x1000,
              R,
              x0,
              x1,
              x2,
              x3
            );
          }

          /**
           * ECB mode decryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _ecb_dec(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            var t = 0;

            _core(
              0x0400, 0x0c00, 0x2000,
              R,
              x0,
              x3,
              x2,
              x1
            );

            t = S1, S1 = S3, S3 = t;
          }


          /**
           * CBC mode encryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _cbc_enc(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            _core(
              0x0000, 0x0800, 0x1000,
              R,
              I0 ^ x0,
              I1 ^ x1,
              I2 ^ x2,
              I3 ^ x3
            );

            I0 = S0,
              I1 = S1,
              I2 = S2,
              I3 = S3;
          }

          /**
           * CBC mode decryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _cbc_dec(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            var t = 0;

            _core(
              0x0400, 0x0c00, 0x2000,
              R,
              x0,
              x3,
              x2,
              x1
            );

            t = S1, S1 = S3, S3 = t;

            S0 = S0 ^ I0,
              S1 = S1 ^ I1,
              S2 = S2 ^ I2,
              S3 = S3 ^ I3;

            I0 = x0,
              I1 = x1,
              I2 = x2,
              I3 = x3;
          }

          /**
           * CFB mode encryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _cfb_enc(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            _core(
              0x0000, 0x0800, 0x1000,
              R,
              I0,
              I1,
              I2,
              I3
            );

            I0 = S0 = S0 ^ x0,
              I1 = S1 = S1 ^ x1,
              I2 = S2 = S2 ^ x2,
              I3 = S3 = S3 ^ x3;
          }


          /**
           * CFB mode decryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _cfb_dec(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            _core(
              0x0000, 0x0800, 0x1000,
              R,
              I0,
              I1,
              I2,
              I3
            );

            S0 = S0 ^ x0,
              S1 = S1 ^ x1,
              S2 = S2 ^ x2,
              S3 = S3 ^ x3;

            I0 = x0,
              I1 = x1,
              I2 = x2,
              I3 = x3;
          }

          /**
           * OFB mode encryption / decryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _ofb(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            _core(
              0x0000, 0x0800, 0x1000,
              R,
              I0,
              I1,
              I2,
              I3
            );

            I0 = S0,
              I1 = S1,
              I2 = S2,
              I3 = S3;

            S0 = S0 ^ x0,
              S1 = S1 ^ x1,
              S2 = S2 ^ x2,
              S3 = S3 ^ x3;
          }

          /**
           * CTR mode encryption / decryption
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _ctr(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            _core(
              0x0000, 0x0800, 0x1000,
              R,
              N0,
              N1,
              N2,
              N3
            );

            N3 = (~M3 & N3) | M3 & (N3 + 1);
              N2 = (~M2 & N2) | M2 & (N2 + ((N3 | 0) == 0));
              N1 = (~M1 & N1) | M1 & (N1 + ((N2 | 0) == 0));
              N0 = (~M0 & N0) | M0 & (N0 + ((N1 | 0) == 0));

            S0 = S0 ^ x0;
              S1 = S1 ^ x1;
              S2 = S2 ^ x2;
              S3 = S3 ^ x3;
          }

          /**
           * GCM mode MAC calculation
           * @param {number} x0 - 128-bit input block vector
           * @param {number} x1 - 128-bit input block vector
           * @param {number} x2 - 128-bit input block vector
           * @param {number} x3 - 128-bit input block vector
           */
          function _gcm_mac(x0, x1, x2, x3) {
            x0 = x0 | 0;
            x1 = x1 | 0;
            x2 = x2 | 0;
            x3 = x3 | 0;

            var y0 = 0, y1 = 0, y2 = 0, y3 = 0,
              z0 = 0, z1 = 0, z2 = 0, z3 = 0,
              i = 0, c = 0;

            x0 = x0 ^ I0,
              x1 = x1 ^ I1,
              x2 = x2 ^ I2,
              x3 = x3 ^ I3;

            y0 = H0 | 0,
              y1 = H1 | 0,
              y2 = H2 | 0,
              y3 = H3 | 0;

            for (; (i | 0) < 128; i = (i + 1) | 0) {
              if (y0 >>> 31) {
                z0 = z0 ^ x0,
                  z1 = z1 ^ x1,
                  z2 = z2 ^ x2,
                  z3 = z3 ^ x3;
              }

              y0 = (y0 << 1) | (y1 >>> 31),
                y1 = (y1 << 1) | (y2 >>> 31),
                y2 = (y2 << 1) | (y3 >>> 31),
                y3 = (y3 << 1);

              c = x3 & 1;

              x3 = (x3 >>> 1) | (x2 << 31),
                x2 = (x2 >>> 1) | (x1 << 31),
                x1 = (x1 >>> 1) | (x0 << 31),
                x0 = (x0 >>> 1);

              if (c) x0 = x0 ^ 0xe1000000;
            }

            I0 = z0,
              I1 = z1,
              I2 = z2,
              I3 = z3;
          }

          /**
           * Set the internal rounds number.
           * @instance
           * @memberof AES_asm
           * @param {number} r - number if inner AES rounds
           */
          function set_rounds(r) {
            r = r | 0;
            R = r;
          }

          /**
           * Populate the internal state of the module.
           * @instance
           * @memberof AES_asm
           * @param {number} s0 - state vector
           * @param {number} s1 - state vector
           * @param {number} s2 - state vector
           * @param {number} s3 - state vector
           */
          function set_state(s0, s1, s2, s3) {
            s0 = s0 | 0;
            s1 = s1 | 0;
            s2 = s2 | 0;
            s3 = s3 | 0;

            S0 = s0,
              S1 = s1,
              S2 = s2,
              S3 = s3;
          }

          /**
           * Populate the internal iv of the module.
           * @instance
           * @memberof AES_asm
           * @param {number} i0 - iv vector
           * @param {number} i1 - iv vector
           * @param {number} i2 - iv vector
           * @param {number} i3 - iv vector
           */
          function set_iv(i0, i1, i2, i3) {
            i0 = i0 | 0;
            i1 = i1 | 0;
            i2 = i2 | 0;
            i3 = i3 | 0;

            I0 = i0,
              I1 = i1,
              I2 = i2,
              I3 = i3;
          }

          /**
           * Set nonce for CTR-family modes.
           * @instance
           * @memberof AES_asm
           * @param {number} n0 - nonce vector
           * @param {number} n1 - nonce vector
           * @param {number} n2 - nonce vector
           * @param {number} n3 - nonce vector
           */
          function set_nonce(n0, n1, n2, n3) {
            n0 = n0 | 0;
            n1 = n1 | 0;
            n2 = n2 | 0;
            n3 = n3 | 0;

            N0 = n0,
              N1 = n1,
              N2 = n2,
              N3 = n3;
          }

          /**
           * Set counter mask for CTR-family modes.
           * @instance
           * @memberof AES_asm
           * @param {number} m0 - counter mask vector
           * @param {number} m1 - counter mask vector
           * @param {number} m2 - counter mask vector
           * @param {number} m3 - counter mask vector
           */
          function set_mask(m0, m1, m2, m3) {
            m0 = m0 | 0;
            m1 = m1 | 0;
            m2 = m2 | 0;
            m3 = m3 | 0;

            M0 = m0,
              M1 = m1,
              M2 = m2,
              M3 = m3;
          }

          /**
           * Set counter for CTR-family modes.
           * @instance
           * @memberof AES_asm
           * @param {number} c0 - counter vector
           * @param {number} c1 - counter vector
           * @param {number} c2 - counter vector
           * @param {number} c3 - counter vector
           */
          function set_counter(c0, c1, c2, c3) {
            c0 = c0 | 0;
            c1 = c1 | 0;
            c2 = c2 | 0;
            c3 = c3 | 0;

            N3 = (~M3 & N3) | M3 & c3,
              N2 = (~M2 & N2) | M2 & c2,
              N1 = (~M1 & N1) | M1 & c1,
              N0 = (~M0 & N0) | M0 & c0;
          }

          /**
           * Store the internal state vector into the heap.
           * @instance
           * @memberof AES_asm
           * @param {number} pos - offset where to put the data
           * @return {number} The number of bytes have been written into the heap, always 16.
           */
          function get_state(pos) {
            pos = pos | 0;

            if (pos & 15) return -1;

            DATA[pos | 0] = S0 >>> 24,
              DATA[pos | 1] = S0 >>> 16 & 255,
              DATA[pos | 2] = S0 >>> 8 & 255,
              DATA[pos | 3] = S0 & 255,
              DATA[pos | 4] = S1 >>> 24,
              DATA[pos | 5] = S1 >>> 16 & 255,
              DATA[pos | 6] = S1 >>> 8 & 255,
              DATA[pos | 7] = S1 & 255,
              DATA[pos | 8] = S2 >>> 24,
              DATA[pos | 9] = S2 >>> 16 & 255,
              DATA[pos | 10] = S2 >>> 8 & 255,
              DATA[pos | 11] = S2 & 255,
              DATA[pos | 12] = S3 >>> 24,
              DATA[pos | 13] = S3 >>> 16 & 255,
              DATA[pos | 14] = S3 >>> 8 & 255,
              DATA[pos | 15] = S3 & 255;

            return 16;
          }

          /**
           * Store the internal iv vector into the heap.
           * @instance
           * @memberof AES_asm
           * @param {number} pos - offset where to put the data
           * @return {number} The number of bytes have been written into the heap, always 16.
           */
          function get_iv(pos) {
            pos = pos | 0;

            if (pos & 15) return -1;

            DATA[pos | 0] = I0 >>> 24,
              DATA[pos | 1] = I0 >>> 16 & 255,
              DATA[pos | 2] = I0 >>> 8 & 255,
              DATA[pos | 3] = I0 & 255,
              DATA[pos | 4] = I1 >>> 24,
              DATA[pos | 5] = I1 >>> 16 & 255,
              DATA[pos | 6] = I1 >>> 8 & 255,
              DATA[pos | 7] = I1 & 255,
              DATA[pos | 8] = I2 >>> 24,
              DATA[pos | 9] = I2 >>> 16 & 255,
              DATA[pos | 10] = I2 >>> 8 & 255,
              DATA[pos | 11] = I2 & 255,
              DATA[pos | 12] = I3 >>> 24,
              DATA[pos | 13] = I3 >>> 16 & 255,
              DATA[pos | 14] = I3 >>> 8 & 255,
              DATA[pos | 15] = I3 & 255;

            return 16;
          }

          /**
           * GCM initialization.
           * @instance
           * @memberof AES_asm
           */
          function gcm_init() {
            _ecb_enc(0, 0, 0, 0);
            H0 = S0,
              H1 = S1,
              H2 = S2,
              H3 = S3;
          }

          /**
           * Perform ciphering operation on the supplied data.
           * @instance
           * @memberof AES_asm
           * @param {number} mode - block cipher mode (see {@link AES_asm} mode constants)
           * @param {number} pos - offset of the data being processed
           * @param {number} len - length of the data being processed
           * @return {number} Actual amount of data have been processed.
           */
          function cipher(mode, pos, len) {
            mode = mode | 0;
            pos = pos | 0;
            len = len | 0;

            var ret = 0;

            if (pos & 15) return -1;

            while ((len | 0) >= 16) {
              _cipher_modes[mode & 7](
                DATA[pos | 0] << 24 | DATA[pos | 1] << 16 | DATA[pos | 2] << 8 | DATA[pos | 3],
                DATA[pos | 4] << 24 | DATA[pos | 5] << 16 | DATA[pos | 6] << 8 | DATA[pos | 7],
                DATA[pos | 8] << 24 | DATA[pos | 9] << 16 | DATA[pos | 10] << 8 | DATA[pos | 11],
                DATA[pos | 12] << 24 | DATA[pos | 13] << 16 | DATA[pos | 14] << 8 | DATA[pos | 15]
              );

              DATA[pos | 0] = S0 >>> 24,
                DATA[pos | 1] = S0 >>> 16 & 255,
                DATA[pos | 2] = S0 >>> 8 & 255,
                DATA[pos | 3] = S0 & 255,
                DATA[pos | 4] = S1 >>> 24,
                DATA[pos | 5] = S1 >>> 16 & 255,
                DATA[pos | 6] = S1 >>> 8 & 255,
                DATA[pos | 7] = S1 & 255,
                DATA[pos | 8] = S2 >>> 24,
                DATA[pos | 9] = S2 >>> 16 & 255,
                DATA[pos | 10] = S2 >>> 8 & 255,
                DATA[pos | 11] = S2 & 255,
                DATA[pos | 12] = S3 >>> 24,
                DATA[pos | 13] = S3 >>> 16 & 255,
                DATA[pos | 14] = S3 >>> 8 & 255,
                DATA[pos | 15] = S3 & 255;

              ret = (ret + 16) | 0,
                pos = (pos + 16) | 0,
                len = (len - 16) | 0;
            }

            return ret | 0;
          }

          /**
           * Calculates MAC of the supplied data.
           * @instance
           * @memberof AES_asm
           * @param {number} mode - block cipher mode (see {@link AES_asm} mode constants)
           * @param {number} pos - offset of the data being processed
           * @param {number} len - length of the data being processed
           * @return {number} Actual amount of data have been processed.
           */
          function mac(mode, pos, len) {
            mode = mode | 0;
            pos = pos | 0;
            len = len | 0;

            var ret = 0;

            if (pos & 15) return -1;

            while ((len | 0) >= 16) {
              _mac_modes[mode & 1](
                DATA[pos | 0] << 24 | DATA[pos | 1] << 16 | DATA[pos | 2] << 8 | DATA[pos | 3],
                DATA[pos | 4] << 24 | DATA[pos | 5] << 16 | DATA[pos | 6] << 8 | DATA[pos | 7],
                DATA[pos | 8] << 24 | DATA[pos | 9] << 16 | DATA[pos | 10] << 8 | DATA[pos | 11],
                DATA[pos | 12] << 24 | DATA[pos | 13] << 16 | DATA[pos | 14] << 8 | DATA[pos | 15]
              );

              ret = (ret + 16) | 0,
                pos = (pos + 16) | 0,
                len = (len - 16) | 0;
            }

            return ret | 0;
          }

          /**
           * AES cipher modes table (virual methods)
           */
          var _cipher_modes = [_ecb_enc, _ecb_dec, _cbc_enc, _cbc_dec, _cfb_enc, _cfb_dec, _ofb, _ctr];

          /**
           * AES MAC modes table (virual methods)
           */
          var _mac_modes = [_cbc_enc, _gcm_mac];

          /**
           * Asm.js module exports
           */
          return {
            set_rounds: set_rounds,
            set_state: set_state,
            set_iv: set_iv,
            set_nonce: set_nonce,
            set_mask: set_mask,
            set_counter: set_counter,
            get_state: get_state,
            get_iv: get_iv,
            gcm_init: gcm_init,
            cipher: cipher,
            mac: mac,
          };
        }(stdlib, foreign, buffer);

        asm.set_key = set_key;

        return asm;
      };

      /**
       * AES enciphering mode constants
       * @enum {number}
       * @const
       */
      wrapper.ENC = {
        ECB: 0,
        CBC: 2,
        CFB: 4,
        OFB: 6,
        CTR: 7,
      },

        /**
         * AES deciphering mode constants
         * @enum {number}
         * @const
         */
        wrapper.DEC = {
          ECB: 1,
          CBC: 3,
          CFB: 5,
          OFB: 6,
          CTR: 7,
        },

        /**
         * AES MAC mode constants
         * @enum {number}
         * @const
         */
        wrapper.MAC = {
          CBC: 0,
          GCM: 1,
        };

      /**
       * Heap data offset
       * @type {number}
       * @const
       */
      wrapper.HEAP_DATA = 0x4000;

      return wrapper;
    }();

    var AES = /** @class */ (function () {
        function AES(key, iv, padding, mode, heap, asm) {
            if (padding === void 0) { padding = true; }
            this.pos = 0;
            this.len = 0;
            this.mode = mode;
            // The AES "worker"
            this.heap = heap ? heap : _heap_init().subarray(AES_asm.HEAP_DATA);
            this.asm = asm ? asm : new AES_asm(null, this.heap.buffer);
            // The AES object state
            this.pos = 0;
            this.len = 0;
            // Key
            var keylen = key.length;
            if (keylen !== 16 && keylen !== 24 && keylen !== 32)
                throw new IllegalArgumentError('illegal key size');
            var keyview = new DataView(key.buffer, key.byteOffset, key.byteLength);
            this.asm.set_key(keylen >> 2, keyview.getUint32(0), keyview.getUint32(4), keyview.getUint32(8), keyview.getUint32(12), keylen > 16 ? keyview.getUint32(16) : 0, keylen > 16 ? keyview.getUint32(20) : 0, keylen > 24 ? keyview.getUint32(24) : 0, keylen > 24 ? keyview.getUint32(28) : 0);
            // IV
            if (iv !== undefined) {
                if (iv.length !== 16)
                    throw new IllegalArgumentError('illegal iv size');
                var ivview = new DataView(iv.buffer, iv.byteOffset, iv.byteLength);
                this.asm.set_iv(ivview.getUint32(0), ivview.getUint32(4), ivview.getUint32(8), ivview.getUint32(12));
            }
            else {
                this.asm.set_iv(0, 0, 0, 0);
            }
            this.padding = padding;
        }
        AES.prototype.AES_Encrypt_process = function (data) {
            if (!is_bytes(data))
                throw new TypeError("data isn't of expected type");
            var asm = this.asm;
            var heap = this.heap;
            var amode = AES_asm.ENC[this.mode];
            var hpos = AES_asm.HEAP_DATA;
            var pos = this.pos;
            var len = this.len;
            var dpos = 0;
            var dlen = data.length || 0;
            var rpos = 0;
            var rlen = (len + dlen) & -16;
            var wlen = 0;
            var result = new Uint8Array(rlen);
            while (dlen > 0) {
                wlen = _heap_write(heap, pos + len, data, dpos, dlen);
                len += wlen;
                dpos += wlen;
                dlen -= wlen;
                wlen = asm.cipher(amode, hpos + pos, len);
                if (wlen)
                    result.set(heap.subarray(pos, pos + wlen), rpos);
                rpos += wlen;
                if (wlen < len) {
                    pos += wlen;
                    len -= wlen;
                }
                else {
                    pos = 0;
                    len = 0;
                }
            }
            this.pos = pos;
            this.len = len;
            return result;
        };
        AES.prototype.AES_Encrypt_finish = function () {
            var asm = this.asm;
            var heap = this.heap;
            var amode = AES_asm.ENC[this.mode];
            var hpos = AES_asm.HEAP_DATA;
            var pos = this.pos;
            var len = this.len;
            var plen = 16 - (len % 16);
            var rlen = len;
            if (this.hasOwnProperty('padding')) {
                if (this.padding) {
                    for (var p = 0; p < plen; ++p) {
                        heap[pos + len + p] = plen;
                    }
                    len += plen;
                    rlen = len;
                }
                else if (len % 16) {
                    throw new IllegalArgumentError('data length must be a multiple of the block size');
                }
            }
            else {
                len += plen;
            }
            var result = new Uint8Array(rlen);
            if (len)
                asm.cipher(amode, hpos + pos, len);
            if (rlen)
                result.set(heap.subarray(pos, pos + rlen));
            this.pos = 0;
            this.len = 0;
            return result;
        };
        AES.prototype.AES_Decrypt_process = function (data) {
            if (!is_bytes(data))
                throw new TypeError("data isn't of expected type");
            var asm = this.asm;
            var heap = this.heap;
            var amode = AES_asm.DEC[this.mode];
            var hpos = AES_asm.HEAP_DATA;
            var pos = this.pos;
            var len = this.len;
            var dpos = 0;
            var dlen = data.length || 0;
            var rpos = 0;
            var rlen = (len + dlen) & -16;
            var plen = 0;
            var wlen = 0;
            if (this.padding) {
                plen = len + dlen - rlen || 16;
                rlen -= plen;
            }
            var result = new Uint8Array(rlen);
            while (dlen > 0) {
                wlen = _heap_write(heap, pos + len, data, dpos, dlen);
                len += wlen;
                dpos += wlen;
                dlen -= wlen;
                wlen = asm.cipher(amode, hpos + pos, len - (!dlen ? plen : 0));
                if (wlen)
                    result.set(heap.subarray(pos, pos + wlen), rpos);
                rpos += wlen;
                if (wlen < len) {
                    pos += wlen;
                    len -= wlen;
                }
                else {
                    pos = 0;
                    len = 0;
                }
            }
            this.pos = pos;
            this.len = len;
            return result;
        };
        AES.prototype.AES_Decrypt_finish = function () {
            var asm = this.asm;
            var heap = this.heap;
            var amode = AES_asm.DEC[this.mode];
            var hpos = AES_asm.HEAP_DATA;
            var pos = this.pos;
            var len = this.len;
            var rlen = len;
            if (len > 0) {
                if (len % 16) {
                    if (this.hasOwnProperty('padding')) {
                        throw new IllegalArgumentError('data length must be a multiple of the block size');
                    }
                    else {
                        len += 16 - (len % 16);
                    }
                }
                asm.cipher(amode, hpos + pos, len);
                if (this.hasOwnProperty('padding') && this.padding) {
                    var pad = heap[pos + rlen - 1];
                    if (pad < 1 || pad > 16 || pad > rlen)
                        throw new SecurityError('bad padding');
                    var pcheck = 0;
                    for (var i = pad; i > 1; i--)
                        pcheck |= pad ^ heap[pos + rlen - i];
                    if (pcheck)
                        throw new SecurityError('bad padding');
                    rlen -= pad;
                }
            }
            var result = new Uint8Array(rlen);
            if (rlen > 0) {
                result.set(heap.subarray(pos, pos + rlen));
            }
            this.pos = 0;
            this.len = 0;
            return result;
        };
        return AES;
    }());

    var AES_CBC = /** @class */ (function () {
        function AES_CBC(key, iv, padding, aes) {
            if (padding === void 0) { padding = true; }
            this.aes = aes ? aes : new AES(key, iv, padding, 'CBC');
        }
        AES_CBC.encrypt = function (data, key, padding, iv) {
            if (padding === void 0) { padding = true; }
            return new AES_CBC(key, iv, padding).encrypt(data);
        };
        AES_CBC.decrypt = function (data, key, padding, iv) {
            if (padding === void 0) { padding = true; }
            return new AES_CBC(key, iv, padding).decrypt(data);
        };
        AES_CBC.prototype.encrypt = function (data) {
            var r1 = this.aes.AES_Encrypt_process(data);
            var r2 = this.aes.AES_Encrypt_finish();
            return joinBytes(r1, r2);
        };
        AES_CBC.prototype.decrypt = function (data) {
            var r1 = this.aes.AES_Decrypt_process(data);
            var r2 = this.aes.AES_Decrypt_finish();
            return joinBytes(r1, r2);
        };
        return AES_CBC;
    }());

    /**
     * Counter with CBC-MAC (CCM)
     *
     * Due to JS limitations (52 bits of Number precision) maximum encrypted message length
     * is limited to ~4 PiB ( 2^52 - 16 ) per `nonce`-`key` pair.
     * That also limits `lengthSize` parameter maximum value to 7 (not 8 as described in RFC3610).
     *
     * Additional authenticated data `adata` maximum length is chosen to be no more than 65279 bytes ( 2^16 - 2^8 ),
     * which is considered enough for the most of use-cases.
     *
     * And one more important thing: in case of progressive ciphering of a data stream (in other
     * words when data can't be held in-memory at a whole and are ciphered chunk-by-chunk)
     * you have to know the `dataLength` in advance and pass that value to the cipher options.
     */
    var _AES_CCM_adata_maxLength = 65279; // 2^16 - 2^8
    var _AES_CCM_data_maxLength = 4503599627370480; // 2^52 - 2^4
    var AES_CCM = /** @class */ (function () {
        function AES_CCM(key, nonce, adata, tagSize, dataLength, aes) {
            if (tagSize === void 0) { tagSize = 16; }
            this.counter = 1;
            this.dataLength = -1;
            this.aes = aes ? aes : new AES(key, undefined, undefined, 'CCM');
            // Tag size
            if (tagSize < 4 || tagSize > 16 || tagSize & 1)
                throw new IllegalArgumentError('illegal tagSize value');
            this.tagSize = tagSize;
            // Nonce
            this.nonce = nonce;
            if (nonce.length < 8 || nonce.length > 13)
                throw new IllegalArgumentError('illegal nonce length');
            this.lengthSize = 15 - nonce.length;
            nonce = new Uint8Array(nonce.length + 1);
            nonce[0] = this.lengthSize - 1;
            nonce.set(this.nonce, 1);
            if (dataLength < 0 || dataLength > _AES_CCM_data_maxLength || dataLength > Math.pow(2, 8 * this.lengthSize) - 16)
                throw new IllegalArgumentError('illegal dataLength value');
            if (adata !== undefined) {
                if (adata.length > _AES_CCM_adata_maxLength)
                    throw new IllegalArgumentError('illegal adata length');
                this.adata = adata.length ? adata : undefined;
            }
            this.dataLength = dataLength;
            this.counter = 1;
            this.AES_CCM_calculate_iv();
            this.AES_CTR_set_options(nonce, this.counter, 8 * this.lengthSize);
        }
        AES_CCM.encrypt = function (clear, key, nonce, adata, tagsize) {
            if (tagsize === void 0) { tagsize = 16; }
            return new AES_CCM(key, nonce, adata, tagsize, clear.length).encrypt(clear);
        };
        AES_CCM.decrypt = function (cipher, key, nonce, adata, tagsize) {
            if (tagsize === void 0) { tagsize = 16; }
            return new AES_CCM(key, nonce, adata, tagsize, cipher.length - tagsize).decrypt(cipher);
        };
        AES_CCM.prototype.encrypt = function (data) {
            this.dataLength = data.length || 0;
            var result1 = this.AES_CCM_Encrypt_process(data);
            var result2 = this.AES_CCM_Encrypt_finish();
            var result = new Uint8Array(result1.length + result2.length);
            if (result1.length)
                result.set(result1);
            if (result2.length)
                result.set(result2, result1.length);
            return result;
        };
        AES_CCM.prototype.decrypt = function (data) {
            this.dataLength = data.length || 0;
            var result1 = this.AES_CCM_Decrypt_process(data);
            var result2 = this.AES_CCM_Decrypt_finish();
            var result = new Uint8Array(result1.length + result2.length);
            if (result1.length)
                result.set(result1);
            if (result2.length)
                result.set(result2, result1.length);
            return result;
        };
        AES_CCM.prototype.AES_CCM_calculate_iv = function () {
            var nonce = this.nonce;
            var adata = this.adata;
            var tagSize = this.tagSize;
            var lengthSize = this.lengthSize;
            var dataLength = this.dataLength;
            var data = new Uint8Array(16 + (adata ? 2 + adata.length : 0));
            // B0: flags(adata?, M', L'), nonce, len(data)
            data[0] = (adata ? 64 : 0) | ((tagSize - 2) << 2) | (lengthSize - 1);
            data.set(nonce, 1);
            if (lengthSize > 6)
                data[9] = ((dataLength / 0x100000000) >>> 16) & 15;
            if (lengthSize > 5)
                data[10] = ((dataLength / 0x100000000) >>> 8) & 255;
            if (lengthSize > 4)
                data[11] = (dataLength / 0x100000000) & 255;
            if (lengthSize > 3)
                data[12] = dataLength >>> 24;
            if (lengthSize > 2)
                data[13] = (dataLength >>> 16) & 255;
            data[14] = (dataLength >>> 8) & 255;
            data[15] = dataLength & 255;
            // B*: len(adata), adata
            if (adata) {
                data[16] = (adata.length >>> 8) & 255;
                data[17] = adata.length & 255;
                data.set(adata, 18);
            }
            this._cbc_mac_process(data);
            this.aes.asm.get_state(AES_asm.HEAP_DATA);
            var iv = new Uint8Array(this.aes.heap.subarray(0, 16));
            var ivview = new DataView(iv.buffer, iv.byteOffset, iv.byteLength);
            this.aes.asm.set_iv(ivview.getUint32(0), ivview.getUint32(4), ivview.getUint32(8), ivview.getUint32(12));
        };
        AES_CCM.prototype._cbc_mac_process = function (data) {
            var heap = this.aes.heap;
            var asm = this.aes.asm;
            var dpos = 0;
            var dlen = data.length || 0;
            var wlen = 0;
            while (dlen > 0) {
                wlen = _heap_write(heap, 0, data, dpos, dlen);
                while (wlen & 15)
                    heap[wlen++] = 0;
                dpos += wlen;
                dlen -= wlen;
                asm.mac(AES_asm.MAC.CBC, AES_asm.HEAP_DATA, wlen);
            }
        };
        AES_CCM.prototype.AES_CCM_Encrypt_process = function (data) {
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var dpos = 0;
            var dlen = data.length || 0;
            var counter = this.counter;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var rlen = (len + dlen) & -16;
            var rpos = 0;
            var wlen = 0;
            if (((counter - 1) << 4) + len + dlen > _AES_CCM_data_maxLength)
                // ??? should check against lengthSize
                throw new RangeError('counter overflow');
            var result = new Uint8Array(rlen);
            while (dlen > 0) {
                wlen = _heap_write(heap, pos + len, data, dpos, dlen);
                len += wlen;
                dpos += wlen;
                dlen -= wlen;
                wlen = asm.mac(AES_asm.MAC.CBC, AES_asm.HEAP_DATA + pos, len);
                wlen = asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA + pos, wlen);
                if (wlen)
                    result.set(heap.subarray(pos, pos + wlen), rpos);
                counter += wlen >>> 4;
                rpos += wlen;
                if (wlen < len) {
                    pos += wlen;
                    len -= wlen;
                }
                else {
                    pos = 0;
                    len = 0;
                }
            }
            this.counter = counter;
            this.aes.pos = pos;
            this.aes.len = len;
            return result;
        };
        AES_CCM.prototype.AES_CCM_Encrypt_finish = function () {
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var tagSize = this.tagSize;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var result = new Uint8Array(len + tagSize);
            var i = len;
            for (; i & 15; i++)
                heap[pos + i] = 0;
            asm.mac(AES_asm.MAC.CBC, AES_asm.HEAP_DATA + pos, i);
            asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA + pos, i);
            if (len)
                result.set(heap.subarray(pos, pos + len));
            asm.set_counter(0, 0, 0, 0);
            asm.get_iv(AES_asm.HEAP_DATA);
            asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA, 16);
            result.set(heap.subarray(0, tagSize), len);
            this.counter = 1;
            this.aes.pos = 0;
            this.aes.len = 0;
            return result;
        };
        AES_CCM.prototype.AES_CCM_Decrypt_process = function (data) {
            var dpos = 0;
            var dlen = data.length || 0;
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var counter = this.counter;
            var tagSize = this.tagSize;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var rpos = 0;
            var rlen = len + dlen > tagSize ? (len + dlen - tagSize) & -16 : 0;
            var tlen = len + dlen - rlen;
            var wlen = 0;
            if (((counter - 1) << 4) + len + dlen > _AES_CCM_data_maxLength)
                throw new RangeError('counter overflow');
            var result = new Uint8Array(rlen);
            while (dlen > tlen) {
                wlen = _heap_write(heap, pos + len, data, dpos, dlen - tlen);
                len += wlen;
                dpos += wlen;
                dlen -= wlen;
                wlen = asm.cipher(AES_asm.DEC.CTR, AES_asm.HEAP_DATA + pos, wlen);
                wlen = asm.mac(AES_asm.MAC.CBC, AES_asm.HEAP_DATA + pos, wlen);
                if (wlen)
                    result.set(heap.subarray(pos, pos + wlen), rpos);
                counter += wlen >>> 4;
                rpos += wlen;
                pos = 0;
                len = 0;
            }
            if (dlen > 0) {
                len += _heap_write(heap, 0, data, dpos, dlen);
            }
            this.counter = counter;
            this.aes.pos = pos;
            this.aes.len = len;
            return result;
        };
        AES_CCM.prototype.AES_CCM_Decrypt_finish = function () {
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var tagSize = this.tagSize;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var rlen = len - tagSize;
            if (len < tagSize)
                throw new IllegalStateError('authentication tag not found');
            var result = new Uint8Array(rlen);
            var atag = new Uint8Array(heap.subarray(pos + rlen, pos + len));
            asm.cipher(AES_asm.DEC.CTR, AES_asm.HEAP_DATA + pos, (rlen + 15) & -16);
            result.set(heap.subarray(pos, pos + rlen));
            var i = rlen;
            for (; i & 15; i++)
                heap[pos + i] = 0;
            asm.mac(AES_asm.MAC.CBC, AES_asm.HEAP_DATA + pos, i);
            asm.set_counter(0, 0, 0, 0);
            asm.get_iv(AES_asm.HEAP_DATA);
            asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA, 16);
            var acheck = 0;
            for (var j = 0; j < tagSize; ++j)
                acheck |= atag[j] ^ heap[j];
            if (acheck)
                throw new SecurityError('data integrity check failed');
            this.counter = 1;
            this.aes.pos = 0;
            this.aes.len = 0;
            return result;
        };
        AES_CCM.prototype.AES_CTR_set_options = function (nonce, counter, size) {
            if (size < 8 || size > 48)
                throw new IllegalArgumentError('illegal counter size');
            var mask = Math.pow(2, size) - 1;
            this.aes.asm.set_mask(0, 0, (mask / 0x100000000) | 0, mask | 0);
            var len = nonce.length;
            if (!len || len > 16)
                throw new IllegalArgumentError('illegal nonce size');
            this.nonce = nonce;
            var view = new DataView(new ArrayBuffer(16));
            new Uint8Array(view.buffer).set(nonce);
            this.aes.asm.set_nonce(view.getUint32(0), view.getUint32(4), view.getUint32(8), view.getUint32(12));
            if (counter < 0 || counter >= Math.pow(2, size))
                throw new IllegalArgumentError('illegal counter value');
            this.counter = counter;
            this.aes.asm.set_counter(0, 0, (counter / 0x100000000) | 0, counter | 0);
        };
        return AES_CCM;
    }());

    var AES_CFB = /** @class */ (function () {
        function AES_CFB(key, iv, aes) {
            this.aes = aes ? aes : new AES(key, iv, true, 'CFB');
            delete this.aes.padding;
        }
        AES_CFB.encrypt = function (data, key, iv) {
            return new AES_CFB(key, iv).encrypt(data);
        };
        AES_CFB.decrypt = function (data, key, iv) {
            return new AES_CFB(key, iv).decrypt(data);
        };
        AES_CFB.prototype.encrypt = function (data) {
            var r1 = this.aes.AES_Encrypt_process(data);
            var r2 = this.aes.AES_Encrypt_finish();
            return joinBytes(r1, r2);
        };
        AES_CFB.prototype.decrypt = function (data) {
            var r1 = this.aes.AES_Decrypt_process(data);
            var r2 = this.aes.AES_Decrypt_finish();
            return joinBytes(r1, r2);
        };
        return AES_CFB;
    }());

    var AES_ECB = /** @class */ (function () {
        function AES_ECB(key, padding, aes) {
            if (padding === void 0) { padding = false; }
            this.aes = aes ? aes : new AES(key, undefined, padding, 'ECB');
        }
        AES_ECB.encrypt = function (data, key, padding) {
            if (padding === void 0) { padding = false; }
            return new AES_ECB(key, padding).encrypt(data);
        };
        AES_ECB.decrypt = function (data, key, padding) {
            if (padding === void 0) { padding = false; }
            return new AES_ECB(key, padding).decrypt(data);
        };
        AES_ECB.prototype.encrypt = function (data) {
            var r1 = this.aes.AES_Encrypt_process(data);
            var r2 = this.aes.AES_Encrypt_finish();
            return joinBytes(r1, r2);
        };
        AES_ECB.prototype.decrypt = function (data) {
            var r1 = this.aes.AES_Decrypt_process(data);
            var r2 = this.aes.AES_Decrypt_finish();
            return joinBytes(r1, r2);
        };
        return AES_ECB;
    }());

    function mul2(data) {
        var t = data[0] & 0x80;
        for (var i = 0; i < 15; i++) {
            data[i] = (data[i] << 1) ^ (data[i + 1] & 0x80 ? 1 : 0);
        }
        data[15] = (data[15] << 1) ^ (t ? 0x87 : 0);
    }
    var AES_CMAC = /** @class */ (function () {
        function AES_CMAC(key) {
            this.bufferLength = 0;
            this.k = new AES_ECB(key).encrypt(new Uint8Array(16));
            mul2(this.k);
            this.cbc = new AES_CBC(key, new Uint8Array(16), false);
            this.buffer = new Uint8Array(16);
            this.result = null;
        }
        AES_CMAC.bytes = function (data, key) {
            return new AES_CMAC(key).process(data).finish().result;
        };
        AES_CMAC.prototype.process = function (data) {
            if (this.bufferLength + data.length > 16) {
                this.cbc.encrypt(this.buffer.subarray(0, this.bufferLength));
                var offset = ((this.bufferLength + data.length - 1) & ~15) - this.bufferLength;
                this.cbc.encrypt(data.subarray(0, offset));
                this.buffer.set(data.subarray(offset));
                this.bufferLength = data.length - offset;
            }
            else {
                this.buffer.set(data, this.bufferLength);
                this.bufferLength += data.length;
            }
            return this;
        };
        AES_CMAC.prototype.finish = function () {
            if (this.bufferLength !== 16) {
                this.buffer[this.bufferLength] = 0x80;
                for (var i = this.bufferLength + 1; i < 16; i++) {
                    this.buffer[i] = 0;
                }
                mul2(this.k);
            }
            for (var i = 0; i < 16; i++) {
                this.buffer[i] ^= this.k[i];
            }
            this.result = this.cbc.encrypt(this.buffer);
            return this;
        };
        return AES_CMAC;
    }());

    var AES_CTR = /** @class */ (function () {
        function AES_CTR(key, nonce, aes) {
            this.aes = aes ? aes : new AES(key, undefined, false, 'CTR');
            delete this.aes.padding;
            this.AES_CTR_set_options(nonce);
        }
        AES_CTR.encrypt = function (data, key, nonce) {
            return new AES_CTR(key, nonce).encrypt(data);
        };
        AES_CTR.decrypt = function (data, key, nonce) {
            return new AES_CTR(key, nonce).encrypt(data);
        };
        AES_CTR.prototype.encrypt = function (data) {
            var r1 = this.aes.AES_Encrypt_process(data);
            var r2 = this.aes.AES_Encrypt_finish();
            return joinBytes(r1, r2);
        };
        AES_CTR.prototype.decrypt = function (data) {
            var r1 = this.aes.AES_Encrypt_process(data);
            var r2 = this.aes.AES_Encrypt_finish();
            return joinBytes(r1, r2);
        };
        AES_CTR.prototype.AES_CTR_set_options = function (nonce, counter, size) {
            if (size !== undefined) {
                if (size < 8 || size > 48)
                    throw new IllegalArgumentError('illegal counter size');
                var mask = Math.pow(2, size) - 1;
                this.aes.asm.set_mask(0, 0, (mask / 0x100000000) | 0, mask | 0);
            }
            else {
                size = 48;
                this.aes.asm.set_mask(0, 0, 0xffff, 0xffffffff);
            }
            if (nonce !== undefined) {
                var len = nonce.length;
                if (!len || len > 16)
                    throw new IllegalArgumentError('illegal nonce size');
                var view = new DataView(new ArrayBuffer(16));
                new Uint8Array(view.buffer).set(nonce);
                this.aes.asm.set_nonce(view.getUint32(0), view.getUint32(4), view.getUint32(8), view.getUint32(12));
            }
            else {
                throw new Error('nonce is required');
            }
            if (counter !== undefined) {
                if (counter < 0 || counter >= Math.pow(2, size))
                    throw new IllegalArgumentError('illegal counter value');
                this.aes.asm.set_counter(0, 0, (counter / 0x100000000) | 0, counter | 0);
            }
        };
        return AES_CTR;
    }());

    var _AES_GCM_data_maxLength = 68719476704; // 2^36 - 2^5
    var AES_GCM = /** @class */ (function () {
        function AES_GCM(key, nonce, adata, tagSize, aes) {
            if (tagSize === void 0) { tagSize = 16; }
            this.tagSize = tagSize;
            this.gamma0 = 0;
            this.counter = 1;
            this.aes = aes ? aes : new AES(key, undefined, false, 'CTR');
            // Init GCM
            this.aes.asm.gcm_init();
            // Tag size
            if (this.tagSize < 4 || this.tagSize > 16)
                throw new IllegalArgumentError('illegal tagSize value');
            // Nonce
            var noncelen = nonce.length || 0;
            var noncebuf = new Uint8Array(16);
            if (noncelen !== 12) {
                this._gcm_mac_process(nonce);
                this.aes.heap[0] = 0;
                this.aes.heap[1] = 0;
                this.aes.heap[2] = 0;
                this.aes.heap[3] = 0;
                this.aes.heap[4] = 0;
                this.aes.heap[5] = 0;
                this.aes.heap[6] = 0;
                this.aes.heap[7] = 0;
                this.aes.heap[8] = 0;
                this.aes.heap[9] = 0;
                this.aes.heap[10] = 0;
                this.aes.heap[11] = noncelen >>> 29;
                this.aes.heap[12] = (noncelen >>> 21) & 255;
                this.aes.heap[13] = (noncelen >>> 13) & 255;
                this.aes.heap[14] = (noncelen >>> 5) & 255;
                this.aes.heap[15] = (noncelen << 3) & 255;
                this.aes.asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA, 16);
                this.aes.asm.get_iv(AES_asm.HEAP_DATA);
                this.aes.asm.set_iv(0, 0, 0, 0);
                noncebuf.set(this.aes.heap.subarray(0, 16));
            }
            else {
                noncebuf.set(nonce);
                noncebuf[15] = 1;
            }
            var nonceview = new DataView(noncebuf.buffer);
            this.gamma0 = nonceview.getUint32(12);
            this.aes.asm.set_nonce(nonceview.getUint32(0), nonceview.getUint32(4), nonceview.getUint32(8), 0);
            this.aes.asm.set_mask(0, 0, 0, 0xffffffff);
            // Associated data
            if (adata !== undefined) {
                if (adata.length > _AES_GCM_data_maxLength)
                    throw new IllegalArgumentError('illegal adata length');
                if (adata.length) {
                    this.adata = adata;
                    this._gcm_mac_process(adata);
                }
                else {
                    this.adata = undefined;
                }
            }
            else {
                this.adata = undefined;
            }
            // Counter
            if (this.counter < 1 || this.counter > 0xffffffff)
                throw new RangeError('counter must be a positive 32-bit integer');
            this.aes.asm.set_counter(0, 0, 0, (this.gamma0 + this.counter) | 0);
        }
        AES_GCM.encrypt = function (cleartext, key, nonce, adata, tagsize) {
            return new AES_GCM(key, nonce, adata, tagsize).encrypt(cleartext);
        };
        AES_GCM.decrypt = function (ciphertext, key, nonce, adata, tagsize) {
            return new AES_GCM(key, nonce, adata, tagsize).decrypt(ciphertext);
        };
        AES_GCM.prototype.encrypt = function (data) {
            return this.AES_GCM_encrypt(data);
        };
        AES_GCM.prototype.decrypt = function (data) {
            return this.AES_GCM_decrypt(data);
        };
        AES_GCM.prototype.AES_GCM_Encrypt_process = function (data) {
            var dpos = 0;
            var dlen = data.length || 0;
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var counter = this.counter;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var rpos = 0;
            var rlen = (len + dlen) & -16;
            var wlen = 0;
            if (((counter - 1) << 4) + len + dlen > _AES_GCM_data_maxLength)
                throw new RangeError('counter overflow');
            var result = new Uint8Array(rlen);
            while (dlen > 0) {
                wlen = _heap_write(heap, pos + len, data, dpos, dlen);
                len += wlen;
                dpos += wlen;
                dlen -= wlen;
                wlen = asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA + pos, len);
                wlen = asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA + pos, wlen);
                if (wlen)
                    result.set(heap.subarray(pos, pos + wlen), rpos);
                counter += wlen >>> 4;
                rpos += wlen;
                if (wlen < len) {
                    pos += wlen;
                    len -= wlen;
                }
                else {
                    pos = 0;
                    len = 0;
                }
            }
            this.counter = counter;
            this.aes.pos = pos;
            this.aes.len = len;
            return result;
        };
        AES_GCM.prototype.AES_GCM_Encrypt_finish = function () {
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var counter = this.counter;
            var tagSize = this.tagSize;
            var adata = this.adata;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var result = new Uint8Array(len + tagSize);
            asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA + pos, (len + 15) & -16);
            if (len)
                result.set(heap.subarray(pos, pos + len));
            var i = len;
            for (; i & 15; i++)
                heap[pos + i] = 0;
            asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA + pos, i);
            var alen = adata !== undefined ? adata.length : 0;
            var clen = ((counter - 1) << 4) + len;
            heap[0] = 0;
            heap[1] = 0;
            heap[2] = 0;
            heap[3] = alen >>> 29;
            heap[4] = alen >>> 21;
            heap[5] = (alen >>> 13) & 255;
            heap[6] = (alen >>> 5) & 255;
            heap[7] = (alen << 3) & 255;
            heap[8] = heap[9] = heap[10] = 0;
            heap[11] = clen >>> 29;
            heap[12] = (clen >>> 21) & 255;
            heap[13] = (clen >>> 13) & 255;
            heap[14] = (clen >>> 5) & 255;
            heap[15] = (clen << 3) & 255;
            asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA, 16);
            asm.get_iv(AES_asm.HEAP_DATA);
            asm.set_counter(0, 0, 0, this.gamma0);
            asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA, 16);
            result.set(heap.subarray(0, tagSize), len);
            this.counter = 1;
            this.aes.pos = 0;
            this.aes.len = 0;
            return result;
        };
        AES_GCM.prototype.AES_GCM_Decrypt_process = function (data) {
            var dpos = 0;
            var dlen = data.length || 0;
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var counter = this.counter;
            var tagSize = this.tagSize;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var rpos = 0;
            var rlen = len + dlen > tagSize ? (len + dlen - tagSize) & -16 : 0;
            var tlen = len + dlen - rlen;
            var wlen = 0;
            if (((counter - 1) << 4) + len + dlen > _AES_GCM_data_maxLength)
                throw new RangeError('counter overflow');
            var result = new Uint8Array(rlen);
            while (dlen > tlen) {
                wlen = _heap_write(heap, pos + len, data, dpos, dlen - tlen);
                len += wlen;
                dpos += wlen;
                dlen -= wlen;
                wlen = asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA + pos, wlen);
                wlen = asm.cipher(AES_asm.DEC.CTR, AES_asm.HEAP_DATA + pos, wlen);
                if (wlen)
                    result.set(heap.subarray(pos, pos + wlen), rpos);
                counter += wlen >>> 4;
                rpos += wlen;
                pos = 0;
                len = 0;
            }
            if (dlen > 0) {
                len += _heap_write(heap, 0, data, dpos, dlen);
            }
            this.counter = counter;
            this.aes.pos = pos;
            this.aes.len = len;
            return result;
        };
        AES_GCM.prototype.AES_GCM_Decrypt_finish = function () {
            var asm = this.aes.asm;
            var heap = this.aes.heap;
            var tagSize = this.tagSize;
            var adata = this.adata;
            var counter = this.counter;
            var pos = this.aes.pos;
            var len = this.aes.len;
            var rlen = len - tagSize;
            if (len < tagSize)
                throw new IllegalStateError('authentication tag not found');
            var result = new Uint8Array(rlen);
            var atag = new Uint8Array(heap.subarray(pos + rlen, pos + len));
            var i = rlen;
            for (; i & 15; i++)
                heap[pos + i] = 0;
            asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA + pos, i);
            asm.cipher(AES_asm.DEC.CTR, AES_asm.HEAP_DATA + pos, i);
            if (rlen)
                result.set(heap.subarray(pos, pos + rlen));
            var alen = adata !== undefined ? adata.length : 0;
            var clen = ((counter - 1) << 4) + len - tagSize;
            heap[0] = 0;
            heap[1] = 0;
            heap[2] = 0;
            heap[3] = alen >>> 29;
            heap[4] = alen >>> 21;
            heap[5] = (alen >>> 13) & 255;
            heap[6] = (alen >>> 5) & 255;
            heap[7] = (alen << 3) & 255;
            heap[8] = heap[9] = heap[10] = 0;
            heap[11] = clen >>> 29;
            heap[12] = (clen >>> 21) & 255;
            heap[13] = (clen >>> 13) & 255;
            heap[14] = (clen >>> 5) & 255;
            heap[15] = (clen << 3) & 255;
            asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA, 16);
            asm.get_iv(AES_asm.HEAP_DATA);
            asm.set_counter(0, 0, 0, this.gamma0);
            asm.cipher(AES_asm.ENC.CTR, AES_asm.HEAP_DATA, 16);
            var acheck = 0;
            for (var i_1 = 0; i_1 < tagSize; ++i_1)
                acheck |= atag[i_1] ^ heap[i_1];
            if (acheck)
                throw new SecurityError('data integrity check failed');
            this.counter = 1;
            this.aes.pos = 0;
            this.aes.len = 0;
            return result;
        };
        AES_GCM.prototype.AES_GCM_decrypt = function (data) {
            var result1 = this.AES_GCM_Decrypt_process(data);
            var result2 = this.AES_GCM_Decrypt_finish();
            var result = new Uint8Array(result1.length + result2.length);
            if (result1.length)
                result.set(result1);
            if (result2.length)
                result.set(result2, result1.length);
            return result;
        };
        AES_GCM.prototype.AES_GCM_encrypt = function (data) {
            var result1 = this.AES_GCM_Encrypt_process(data);
            var result2 = this.AES_GCM_Encrypt_finish();
            var result = new Uint8Array(result1.length + result2.length);
            if (result1.length)
                result.set(result1);
            if (result2.length)
                result.set(result2, result1.length);
            return result;
        };
        AES_GCM.prototype._gcm_mac_process = function (data) {
            var heap = this.aes.heap;
            var asm = this.aes.asm;
            var dpos = 0;
            var dlen = data.length || 0;
            var wlen = 0;
            while (dlen > 0) {
                wlen = _heap_write(heap, 0, data, dpos, dlen);
                dpos += wlen;
                dlen -= wlen;
                while (wlen & 15)
                    heap[wlen++] = 0;
                asm.mac(AES_asm.MAC.GCM, AES_asm.HEAP_DATA, wlen);
            }
        };
        return AES_GCM;
    }());

    var AES_OFB = /** @class */ (function () {
        function AES_OFB(key, iv, aes) {
            this.aes = aes ? aes : new AES(key, iv, false, 'OFB');
        }
        AES_OFB.encrypt = function (data, key, iv) {
            return new AES_OFB(key, iv).encrypt(data);
        };
        AES_OFB.decrypt = function (data, key, iv) {
            return new AES_OFB(key, iv).decrypt(data);
        };
        AES_OFB.prototype.encrypt = function (data) {
            var r1 = this.aes.AES_Encrypt_process(data);
            var r2 = this.aes.AES_Encrypt_finish();
            return joinBytes(r1, r2);
        };
        AES_OFB.prototype.decrypt = function (data) {
            var r1 = this.aes.AES_Decrypt_process(data);
            var r2 = this.aes.AES_Decrypt_finish();
            return joinBytes(r1, r2);
        };
        return AES_OFB;
    }());

    /**
     * Integers are represented as little endian array of 32-bit limbs.
     * Limbs number is a power of 2 and a multiple of 8 (256 bits).
     * Negative values use two's complement representation.
     */
    var bigint_asm = function ( stdlib, foreign, buffer ) {
        "use asm";

        var SP = 0;

        var HEAP32 = new stdlib.Uint32Array(buffer);

        var imul = stdlib.Math.imul;

        /**
         * Simple stack memory allocator
         *
         * Methods:
         *  sreset
         *  salloc
         *  sfree
         */

        function sreset ( p ) {
            p = p|0;
            SP = p = (p + 31) & -32;
            return p|0;
        }

        function salloc ( l ) {
            l = l|0;
            var p = 0; p = SP;
            SP = p + ((l + 31) & -32)|0;
            return p|0;
        }

        function sfree ( l ) {
            l = l|0;
            SP = SP - ((l + 31) & -32)|0;
        }

        /**
         * Utility functions:
         *  cp
         *  z
         */

        function cp ( l, A, B ) {
            l = l|0;
            A = A|0;
            B = B|0;

            var i = 0;

            if ( (A|0) > (B|0) ) {
                for ( ; (i|0) < (l|0); i = (i+4)|0 ) {
                    HEAP32[(B+i)>>2] = HEAP32[(A+i)>>2];
                }
            }
            else {
                for ( i = (l-4)|0; (i|0) >= 0; i = (i-4)|0 ) {
                    HEAP32[(B+i)>>2] = HEAP32[(A+i)>>2];
                }
            }
        }

        function z ( l, z, A ) {
            l = l|0;
            z = z|0;
            A = A|0;

            var i = 0;

            for ( ; (i|0) < (l|0); i = (i+4)|0 ) {
                HEAP32[(A+i)>>2] = z;
            }
        }

        /**
         * Negate the argument
         *
         * Perform two's complement transformation:
         *
         *  -A = ~A + 1
         *
         * @param A offset of the argment being negated, 32-byte aligned
         * @param lA length of the argument, multiple of 32
         *
         * @param R offset where to place the result to, 32-byte aligned
         * @param lR length to truncate the result to, multiple of 32
         */
        function neg ( A, lA, R, lR ) {
            A  =  A|0;
            lA = lA|0;
            R  =  R|0;
            lR = lR|0;

            var a = 0, c = 0, t = 0, r = 0, i = 0;

            if ( (lR|0) <= 0 )
                lR = lA;

            if ( (lR|0) < (lA|0) )
                lA = lR;

            c = 1;
            for ( ; (i|0) < (lA|0); i = (i+4)|0 ) {
                a = ~HEAP32[(A+i)>>2];
                t = (a & 0xffff) + c|0;
                r = (a >>> 16) + (t >>> 16)|0;
                HEAP32[(R+i)>>2] = (r << 16) | (t & 0xffff);
                c = r >>> 16;
            }

            for ( ; (i|0) < (lR|0); i = (i+4)|0 ) {
                HEAP32[(R+i)>>2] = (c-1)|0;
            }

            return c|0;
        }

        function cmp ( A, lA, B, lB ) {
            A  =  A|0;
            lA = lA|0;
            B  =  B|0;
            lB = lB|0;

            var a = 0, b = 0, i = 0;

            if ( (lA|0) > (lB|0) ) {
                for ( i = (lA-4)|0; (i|0) >= (lB|0); i = (i-4)|0 ) {
                    if ( HEAP32[(A+i)>>2]|0 ) return 1;
                }
            }
            else {
                for ( i = (lB-4)|0; (i|0) >= (lA|0); i = (i-4)|0 ) {
                    if ( HEAP32[(B+i)>>2]|0 ) return -1;
                }
            }

            for ( ; (i|0) >= 0; i = (i-4)|0 ) {
                a = HEAP32[(A+i)>>2]|0, b = HEAP32[(B+i)>>2]|0;
                if ( (a>>>0) < (b>>>0) ) return -1;
                if ( (a>>>0) > (b>>>0) ) return 1;
            }

            return 0;
        }

        /**
         * Test the argument
         *
         * Same as `cmp` with zero.
         */
        function tst ( A, lA ) {
            A  =  A|0;
            lA = lA|0;

            var i = 0;

            for ( i = (lA-4)|0; (i|0) >= 0; i = (i-4)|0 ) {
                if ( HEAP32[(A+i)>>2]|0 ) return (i+4)|0;
            }

            return 0;
        }

        /**
         * Conventional addition
         *
         * @param A offset of the first argument, 32-byte aligned
         * @param lA length of the first argument, multiple of 32
         *
         * @param B offset of the second argument, 32-bit aligned
         * @param lB length of the second argument, multiple of 32
         *
         * @param R offset where to place the result to, 32-byte aligned
         * @param lR length to truncate the result to, multiple of 32
         */
        function add ( A, lA, B, lB, R, lR ) {
            A  =  A|0;
            lA = lA|0;
            B  =  B|0;
            lB = lB|0;
            R  =  R|0;
            lR = lR|0;

            var a = 0, b = 0, c = 0, t = 0, r = 0, i = 0;

            if ( (lA|0) < (lB|0) ) {
                t = A, A = B, B = t;
                t = lA, lA = lB, lB = t;
            }

            if ( (lR|0) <= 0 )
                lR = lA+4|0;

            if ( (lR|0) < (lB|0) )
                lA = lB = lR;

            for ( ; (i|0) < (lB|0); i = (i+4)|0 ) {
                a = HEAP32[(A+i)>>2]|0;
                b = HEAP32[(B+i)>>2]|0;
                t = ( (a & 0xffff) + (b & 0xffff)|0 ) + c|0;
                r = ( (a >>> 16) + (b >>> 16)|0 ) + (t >>> 16)|0;
                HEAP32[(R+i)>>2] = (t & 0xffff) | (r << 16);
                c = r >>> 16;
            }

            for ( ; (i|0) < (lA|0); i = (i+4)|0 ) {
                a = HEAP32[(A+i)>>2]|0;
                t = (a & 0xffff) + c|0;
                r = (a >>> 16) + (t >>> 16)|0;
                HEAP32[(R+i)>>2] = (t & 0xffff) | (r << 16);
                c = r >>> 16;
            }

            for ( ; (i|0) < (lR|0); i = (i+4)|0 ) {
                HEAP32[(R+i)>>2] = c|0;
                c = 0;
            }

            return c|0;
        }

       /**
         * Conventional subtraction
         *
         * @param A offset of the first argument, 32-byte aligned
         * @param lA length of the first argument, multiple of 32
         *
         * @param B offset of the second argument, 32-bit aligned
         * @param lB length of the second argument, multiple of 32
         *
         * @param R offset where to place the result to, 32-byte aligned
         * @param lR length to truncate the result to, multiple of 32
         */
        function sub ( A, lA, B, lB, R, lR ) {
            A  =  A|0;
            lA = lA|0;
            B  =  B|0;
            lB = lB|0;
            R  =  R|0;
            lR = lR|0;

            var a = 0, b = 0, c = 0, t = 0, r = 0, i = 0;

            if ( (lR|0) <= 0 )
                lR = (lA|0) > (lB|0) ? lA+4|0 : lB+4|0;

            if ( (lR|0) < (lA|0) )
                lA = lR;

            if ( (lR|0) < (lB|0) )
                lB = lR;

            if ( (lA|0) < (lB|0) ) {
                for ( ; (i|0) < (lA|0); i = (i+4)|0 ) {
                    a = HEAP32[(A+i)>>2]|0;
                    b = HEAP32[(B+i)>>2]|0;
                    t = ( (a & 0xffff) - (b & 0xffff)|0 ) + c|0;
                    r = ( (a >>> 16) - (b >>> 16)|0 ) + (t >> 16)|0;
                    HEAP32[(R+i)>>2] = (t & 0xffff) | (r << 16);
                    c = r >> 16;
                }

                for ( ; (i|0) < (lB|0); i = (i+4)|0 ) {
                    b = HEAP32[(B+i)>>2]|0;
                    t = c - (b & 0xffff)|0;
                    r = (t >> 16) - (b >>> 16)|0;
                    HEAP32[(R+i)>>2] = (t & 0xffff) | (r << 16);
                    c = r >> 16;
                }
            }
            else {
                for ( ; (i|0) < (lB|0); i = (i+4)|0 ) {
                    a = HEAP32[(A+i)>>2]|0;
                    b = HEAP32[(B+i)>>2]|0;
                    t = ( (a & 0xffff) - (b & 0xffff)|0 ) + c|0;
                    r = ( (a >>> 16) - (b >>> 16)|0 ) + (t >> 16)|0;
                    HEAP32[(R+i)>>2] = (t & 0xffff) | (r << 16);
                    c = r >> 16;
                }

                for ( ; (i|0) < (lA|0); i = (i+4)|0 ) {
                    a = HEAP32[(A+i)>>2]|0;
                    t = (a & 0xffff) + c|0;
                    r = (a >>> 16) + (t >> 16)|0;
                    HEAP32[(R+i)>>2] = (t & 0xffff) | (r << 16);
                    c = r >> 16;
                }
            }

            for ( ; (i|0) < (lR|0); i = (i+4)|0 ) {
                HEAP32[(R+i)>>2] = c|0;
            }

            return c|0;
        }

        /**
         * Conventional multiplication
         *
         * TODO implement Karatsuba algorithm for large multiplicands
         *
         * @param A offset of the first argument, 32-byte aligned
         * @param lA length of the first argument, multiple of 32
         *
         * @param B offset of the second argument, 32-byte aligned
         * @param lB length of the second argument, multiple of 32
         *
         * @param R offset where to place the result to, 32-byte aligned
         * @param lR length to truncate the result to, multiple of 32
         */
        function mul ( A, lA, B, lB, R, lR ) {
            A  =  A|0;
            lA = lA|0;
            B  =  B|0;
            lB = lB|0;
            R  =  R|0;
            lR = lR|0;

            var al0 = 0, al1 = 0, al2 = 0, al3 = 0, al4 = 0, al5 = 0, al6 = 0, al7 = 0, ah0 = 0, ah1 = 0, ah2 = 0, ah3 = 0, ah4 = 0, ah5 = 0, ah6 = 0, ah7 = 0,
                bl0 = 0, bl1 = 0, bl2 = 0, bl3 = 0, bl4 = 0, bl5 = 0, bl6 = 0, bl7 = 0, bh0 = 0, bh1 = 0, bh2 = 0, bh3 = 0, bh4 = 0, bh5 = 0, bh6 = 0, bh7 = 0,
                r0 = 0, r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0, r7 = 0, r8 = 0, r9 = 0, r10 = 0, r11 = 0, r12 = 0, r13 = 0, r14 = 0, r15 = 0,
                u = 0, v = 0, w = 0, m = 0,
                i = 0, Ai = 0, j = 0, Bj = 0, Rk = 0;

            if ( (lA|0) > (lB|0) ) {
                u = A, v = lA;
                A = B, lA = lB;
                B = u, lB = v;
            }

            m = (lA+lB)|0;
            if ( ( (lR|0) > (m|0) ) | ( (lR|0) <= 0 ) )
                lR = m;

            if ( (lR|0) < (lA|0) )
                lA = lR;

            if ( (lR|0) < (lB|0) )
                lB = lR;

            for ( ; (i|0) < (lA|0); i = (i+32)|0 ) {
                Ai = (A+i)|0;

                ah0 = HEAP32[(Ai|0)>>2]|0,
                ah1 = HEAP32[(Ai|4)>>2]|0,
                ah2 = HEAP32[(Ai|8)>>2]|0,
                ah3 = HEAP32[(Ai|12)>>2]|0,
                ah4 = HEAP32[(Ai|16)>>2]|0,
                ah5 = HEAP32[(Ai|20)>>2]|0,
                ah6 = HEAP32[(Ai|24)>>2]|0,
                ah7 = HEAP32[(Ai|28)>>2]|0,
                al0 = ah0 & 0xffff,
                al1 = ah1 & 0xffff,
                al2 = ah2 & 0xffff,
                al3 = ah3 & 0xffff,
                al4 = ah4 & 0xffff,
                al5 = ah5 & 0xffff,
                al6 = ah6 & 0xffff,
                al7 = ah7 & 0xffff,
                ah0 = ah0 >>> 16,
                ah1 = ah1 >>> 16,
                ah2 = ah2 >>> 16,
                ah3 = ah3 >>> 16,
                ah4 = ah4 >>> 16,
                ah5 = ah5 >>> 16,
                ah6 = ah6 >>> 16,
                ah7 = ah7 >>> 16;

                r8 = r9 = r10 = r11 = r12 = r13 = r14 = r15 = 0;

                for ( j = 0; (j|0) < (lB|0); j = (j+32)|0 ) {
                    Bj = (B+j)|0;
                    Rk = (R+(i+j|0))|0;

                    bh0 = HEAP32[(Bj|0)>>2]|0,
                    bh1 = HEAP32[(Bj|4)>>2]|0,
                    bh2 = HEAP32[(Bj|8)>>2]|0,
                    bh3 = HEAP32[(Bj|12)>>2]|0,
                    bh4 = HEAP32[(Bj|16)>>2]|0,
                    bh5 = HEAP32[(Bj|20)>>2]|0,
                    bh6 = HEAP32[(Bj|24)>>2]|0,
                    bh7 = HEAP32[(Bj|28)>>2]|0,
                    bl0 = bh0 & 0xffff,
                    bl1 = bh1 & 0xffff,
                    bl2 = bh2 & 0xffff,
                    bl3 = bh3 & 0xffff,
                    bl4 = bh4 & 0xffff,
                    bl5 = bh5 & 0xffff,
                    bl6 = bh6 & 0xffff,
                    bl7 = bh7 & 0xffff,
                    bh0 = bh0 >>> 16,
                    bh1 = bh1 >>> 16,
                    bh2 = bh2 >>> 16,
                    bh3 = bh3 >>> 16,
                    bh4 = bh4 >>> 16,
                    bh5 = bh5 >>> 16,
                    bh6 = bh6 >>> 16,
                    bh7 = bh7 >>> 16;

                    r0 = HEAP32[(Rk|0)>>2]|0,
                    r1 = HEAP32[(Rk|4)>>2]|0,
                    r2 = HEAP32[(Rk|8)>>2]|0,
                    r3 = HEAP32[(Rk|12)>>2]|0,
                    r4 = HEAP32[(Rk|16)>>2]|0,
                    r5 = HEAP32[(Rk|20)>>2]|0,
                    r6 = HEAP32[(Rk|24)>>2]|0,
                    r7 = HEAP32[(Rk|28)>>2]|0;

                    u = ((imul(al0, bl0)|0) + (r8 & 0xffff)|0) + (r0 & 0xffff)|0;
                    v = ((imul(ah0, bl0)|0) + (r8 >>> 16)|0) + (r0 >>> 16)|0;
                    w = ((imul(al0, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r0 = (w << 16) | (u & 0xffff);

                    u = ((imul(al0, bl1)|0) + (m & 0xffff)|0) + (r1 & 0xffff)|0;
                    v = ((imul(ah0, bl1)|0) + (m >>> 16)|0) + (r1 >>> 16)|0;
                    w = ((imul(al0, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r1 = (w << 16) | (u & 0xffff);

                    u = ((imul(al0, bl2)|0) + (m & 0xffff)|0) + (r2 & 0xffff)|0;
                    v = ((imul(ah0, bl2)|0) + (m >>> 16)|0) + (r2 >>> 16)|0;
                    w = ((imul(al0, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r2 = (w << 16) | (u & 0xffff);

                    u = ((imul(al0, bl3)|0) + (m & 0xffff)|0) + (r3 & 0xffff)|0;
                    v = ((imul(ah0, bl3)|0) + (m >>> 16)|0) + (r3 >>> 16)|0;
                    w = ((imul(al0, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r3 = (w << 16) | (u & 0xffff);

                    u = ((imul(al0, bl4)|0) + (m & 0xffff)|0) + (r4 & 0xffff)|0;
                    v = ((imul(ah0, bl4)|0) + (m >>> 16)|0) + (r4 >>> 16)|0;
                    w = ((imul(al0, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r4 = (w << 16) | (u & 0xffff);

                    u = ((imul(al0, bl5)|0) + (m & 0xffff)|0) + (r5 & 0xffff)|0;
                    v = ((imul(ah0, bl5)|0) + (m >>> 16)|0) + (r5 >>> 16)|0;
                    w = ((imul(al0, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r5 = (w << 16) | (u & 0xffff);

                    u = ((imul(al0, bl6)|0) + (m & 0xffff)|0) + (r6 & 0xffff)|0;
                    v = ((imul(ah0, bl6)|0) + (m >>> 16)|0) + (r6 >>> 16)|0;
                    w = ((imul(al0, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r6 = (w << 16) | (u & 0xffff);

                    u = ((imul(al0, bl7)|0) + (m & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah0, bl7)|0) + (m >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al0, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    r8 = m;

                    u = ((imul(al1, bl0)|0) + (r9 & 0xffff)|0) + (r1 & 0xffff)|0;
                    v = ((imul(ah1, bl0)|0) + (r9 >>> 16)|0) + (r1 >>> 16)|0;
                    w = ((imul(al1, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r1 = (w << 16) | (u & 0xffff);

                    u = ((imul(al1, bl1)|0) + (m & 0xffff)|0) + (r2 & 0xffff)|0;
                    v = ((imul(ah1, bl1)|0) + (m >>> 16)|0) + (r2 >>> 16)|0;
                    w = ((imul(al1, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r2 = (w << 16) | (u & 0xffff);

                    u = ((imul(al1, bl2)|0) + (m & 0xffff)|0) + (r3 & 0xffff)|0;
                    v = ((imul(ah1, bl2)|0) + (m >>> 16)|0) + (r3 >>> 16)|0;
                    w = ((imul(al1, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r3 = (w << 16) | (u & 0xffff);

                    u = ((imul(al1, bl3)|0) + (m & 0xffff)|0) + (r4 & 0xffff)|0;
                    v = ((imul(ah1, bl3)|0) + (m >>> 16)|0) + (r4 >>> 16)|0;
                    w = ((imul(al1, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r4 = (w << 16) | (u & 0xffff);

                    u = ((imul(al1, bl4)|0) + (m & 0xffff)|0) + (r5 & 0xffff)|0;
                    v = ((imul(ah1, bl4)|0) + (m >>> 16)|0) + (r5 >>> 16)|0;
                    w = ((imul(al1, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r5 = (w << 16) | (u & 0xffff);

                    u = ((imul(al1, bl5)|0) + (m & 0xffff)|0) + (r6 & 0xffff)|0;
                    v = ((imul(ah1, bl5)|0) + (m >>> 16)|0) + (r6 >>> 16)|0;
                    w = ((imul(al1, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r6 = (w << 16) | (u & 0xffff);

                    u = ((imul(al1, bl6)|0) + (m & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah1, bl6)|0) + (m >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al1, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    u = ((imul(al1, bl7)|0) + (m & 0xffff)|0) + (r8 & 0xffff)|0;
                    v = ((imul(ah1, bl7)|0) + (m >>> 16)|0) + (r8 >>> 16)|0;
                    w = ((imul(al1, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah1, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r8 = (w << 16) | (u & 0xffff);

                    r9 = m;

                    u = ((imul(al2, bl0)|0) + (r10 & 0xffff)|0) + (r2 & 0xffff)|0;
                    v = ((imul(ah2, bl0)|0) + (r10 >>> 16)|0) + (r2 >>> 16)|0;
                    w = ((imul(al2, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r2 = (w << 16) | (u & 0xffff);

                    u = ((imul(al2, bl1)|0) + (m & 0xffff)|0) + (r3 & 0xffff)|0;
                    v = ((imul(ah2, bl1)|0) + (m >>> 16)|0) + (r3 >>> 16)|0;
                    w = ((imul(al2, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r3 = (w << 16) | (u & 0xffff);

                    u = ((imul(al2, bl2)|0) + (m & 0xffff)|0) + (r4 & 0xffff)|0;
                    v = ((imul(ah2, bl2)|0) + (m >>> 16)|0) + (r4 >>> 16)|0;
                    w = ((imul(al2, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r4 = (w << 16) | (u & 0xffff);

                    u = ((imul(al2, bl3)|0) + (m & 0xffff)|0) + (r5 & 0xffff)|0;
                    v = ((imul(ah2, bl3)|0) + (m >>> 16)|0) + (r5 >>> 16)|0;
                    w = ((imul(al2, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r5 = (w << 16) | (u & 0xffff);

                    u = ((imul(al2, bl4)|0) + (m & 0xffff)|0) + (r6 & 0xffff)|0;
                    v = ((imul(ah2, bl4)|0) + (m >>> 16)|0) + (r6 >>> 16)|0;
                    w = ((imul(al2, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r6 = (w << 16) | (u & 0xffff);

                    u = ((imul(al2, bl5)|0) + (m & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah2, bl5)|0) + (m >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al2, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    u = ((imul(al2, bl6)|0) + (m & 0xffff)|0) + (r8 & 0xffff)|0;
                    v = ((imul(ah2, bl6)|0) + (m >>> 16)|0) + (r8 >>> 16)|0;
                    w = ((imul(al2, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r8 = (w << 16) | (u & 0xffff);

                    u = ((imul(al2, bl7)|0) + (m & 0xffff)|0) + (r9 & 0xffff)|0;
                    v = ((imul(ah2, bl7)|0) + (m >>> 16)|0) + (r9 >>> 16)|0;
                    w = ((imul(al2, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah2, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r9 = (w << 16) | (u & 0xffff);

                    r10 = m;

                    u = ((imul(al3, bl0)|0) + (r11 & 0xffff)|0) + (r3 & 0xffff)|0;
                    v = ((imul(ah3, bl0)|0) + (r11 >>> 16)|0) + (r3 >>> 16)|0;
                    w = ((imul(al3, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r3 = (w << 16) | (u & 0xffff);

                    u = ((imul(al3, bl1)|0) + (m & 0xffff)|0) + (r4 & 0xffff)|0;
                    v = ((imul(ah3, bl1)|0) + (m >>> 16)|0) + (r4 >>> 16)|0;
                    w = ((imul(al3, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r4 = (w << 16) | (u & 0xffff);

                    u = ((imul(al3, bl2)|0) + (m & 0xffff)|0) + (r5 & 0xffff)|0;
                    v = ((imul(ah3, bl2)|0) + (m >>> 16)|0) + (r5 >>> 16)|0;
                    w = ((imul(al3, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r5 = (w << 16) | (u & 0xffff);

                    u = ((imul(al3, bl3)|0) + (m & 0xffff)|0) + (r6 & 0xffff)|0;
                    v = ((imul(ah3, bl3)|0) + (m >>> 16)|0) + (r6 >>> 16)|0;
                    w = ((imul(al3, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r6 = (w << 16) | (u & 0xffff);

                    u = ((imul(al3, bl4)|0) + (m & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah3, bl4)|0) + (m >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al3, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    u = ((imul(al3, bl5)|0) + (m & 0xffff)|0) + (r8 & 0xffff)|0;
                    v = ((imul(ah3, bl5)|0) + (m >>> 16)|0) + (r8 >>> 16)|0;
                    w = ((imul(al3, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r8 = (w << 16) | (u & 0xffff);

                    u = ((imul(al3, bl6)|0) + (m & 0xffff)|0) + (r9 & 0xffff)|0;
                    v = ((imul(ah3, bl6)|0) + (m >>> 16)|0) + (r9 >>> 16)|0;
                    w = ((imul(al3, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r9 = (w << 16) | (u & 0xffff);

                    u = ((imul(al3, bl7)|0) + (m & 0xffff)|0) + (r10 & 0xffff)|0;
                    v = ((imul(ah3, bl7)|0) + (m >>> 16)|0) + (r10 >>> 16)|0;
                    w = ((imul(al3, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah3, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r10 = (w << 16) | (u & 0xffff);

                    r11 = m;

                    u = ((imul(al4, bl0)|0) + (r12 & 0xffff)|0) + (r4 & 0xffff)|0;
                    v = ((imul(ah4, bl0)|0) + (r12 >>> 16)|0) + (r4 >>> 16)|0;
                    w = ((imul(al4, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r4 = (w << 16) | (u & 0xffff);

                    u = ((imul(al4, bl1)|0) + (m & 0xffff)|0) + (r5 & 0xffff)|0;
                    v = ((imul(ah4, bl1)|0) + (m >>> 16)|0) + (r5 >>> 16)|0;
                    w = ((imul(al4, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r5 = (w << 16) | (u & 0xffff);

                    u = ((imul(al4, bl2)|0) + (m & 0xffff)|0) + (r6 & 0xffff)|0;
                    v = ((imul(ah4, bl2)|0) + (m >>> 16)|0) + (r6 >>> 16)|0;
                    w = ((imul(al4, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r6 = (w << 16) | (u & 0xffff);

                    u = ((imul(al4, bl3)|0) + (m & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah4, bl3)|0) + (m >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al4, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    u = ((imul(al4, bl4)|0) + (m & 0xffff)|0) + (r8 & 0xffff)|0;
                    v = ((imul(ah4, bl4)|0) + (m >>> 16)|0) + (r8 >>> 16)|0;
                    w = ((imul(al4, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r8 = (w << 16) | (u & 0xffff);

                    u = ((imul(al4, bl5)|0) + (m & 0xffff)|0) + (r9 & 0xffff)|0;
                    v = ((imul(ah4, bl5)|0) + (m >>> 16)|0) + (r9 >>> 16)|0;
                    w = ((imul(al4, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r9 = (w << 16) | (u & 0xffff);

                    u = ((imul(al4, bl6)|0) + (m & 0xffff)|0) + (r10 & 0xffff)|0;
                    v = ((imul(ah4, bl6)|0) + (m >>> 16)|0) + (r10 >>> 16)|0;
                    w = ((imul(al4, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r10 = (w << 16) | (u & 0xffff);

                    u = ((imul(al4, bl7)|0) + (m & 0xffff)|0) + (r11 & 0xffff)|0;
                    v = ((imul(ah4, bl7)|0) + (m >>> 16)|0) + (r11 >>> 16)|0;
                    w = ((imul(al4, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah4, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r11 = (w << 16) | (u & 0xffff);

                    r12 = m;

                    u = ((imul(al5, bl0)|0) + (r13 & 0xffff)|0) + (r5 & 0xffff)|0;
                    v = ((imul(ah5, bl0)|0) + (r13 >>> 16)|0) + (r5 >>> 16)|0;
                    w = ((imul(al5, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r5 = (w << 16) | (u & 0xffff);

                    u = ((imul(al5, bl1)|0) + (m & 0xffff)|0) + (r6 & 0xffff)|0;
                    v = ((imul(ah5, bl1)|0) + (m >>> 16)|0) + (r6 >>> 16)|0;
                    w = ((imul(al5, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r6 = (w << 16) | (u & 0xffff);

                    u = ((imul(al5, bl2)|0) + (m & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah5, bl2)|0) + (m >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al5, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    u = ((imul(al5, bl3)|0) + (m & 0xffff)|0) + (r8 & 0xffff)|0;
                    v = ((imul(ah5, bl3)|0) + (m >>> 16)|0) + (r8 >>> 16)|0;
                    w = ((imul(al5, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r8 = (w << 16) | (u & 0xffff);

                    u = ((imul(al5, bl4)|0) + (m & 0xffff)|0) + (r9 & 0xffff)|0;
                    v = ((imul(ah5, bl4)|0) + (m >>> 16)|0) + (r9 >>> 16)|0;
                    w = ((imul(al5, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r9 = (w << 16) | (u & 0xffff);

                    u = ((imul(al5, bl5)|0) + (m & 0xffff)|0) + (r10 & 0xffff)|0;
                    v = ((imul(ah5, bl5)|0) + (m >>> 16)|0) + (r10 >>> 16)|0;
                    w = ((imul(al5, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r10 = (w << 16) | (u & 0xffff);

                    u = ((imul(al5, bl6)|0) + (m & 0xffff)|0) + (r11 & 0xffff)|0;
                    v = ((imul(ah5, bl6)|0) + (m >>> 16)|0) + (r11 >>> 16)|0;
                    w = ((imul(al5, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r11 = (w << 16) | (u & 0xffff);

                    u = ((imul(al5, bl7)|0) + (m & 0xffff)|0) + (r12 & 0xffff)|0;
                    v = ((imul(ah5, bl7)|0) + (m >>> 16)|0) + (r12 >>> 16)|0;
                    w = ((imul(al5, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah5, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r12 = (w << 16) | (u & 0xffff);

                    r13 = m;

                    u = ((imul(al6, bl0)|0) + (r14 & 0xffff)|0) + (r6 & 0xffff)|0;
                    v = ((imul(ah6, bl0)|0) + (r14 >>> 16)|0) + (r6 >>> 16)|0;
                    w = ((imul(al6, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r6 = (w << 16) | (u & 0xffff);

                    u = ((imul(al6, bl1)|0) + (m & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah6, bl1)|0) + (m >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al6, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    u = ((imul(al6, bl2)|0) + (m & 0xffff)|0) + (r8 & 0xffff)|0;
                    v = ((imul(ah6, bl2)|0) + (m >>> 16)|0) + (r8 >>> 16)|0;
                    w = ((imul(al6, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r8 = (w << 16) | (u & 0xffff);

                    u = ((imul(al6, bl3)|0) + (m & 0xffff)|0) + (r9 & 0xffff)|0;
                    v = ((imul(ah6, bl3)|0) + (m >>> 16)|0) + (r9 >>> 16)|0;
                    w = ((imul(al6, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r9 = (w << 16) | (u & 0xffff);

                    u = ((imul(al6, bl4)|0) + (m & 0xffff)|0) + (r10 & 0xffff)|0;
                    v = ((imul(ah6, bl4)|0) + (m >>> 16)|0) + (r10 >>> 16)|0;
                    w = ((imul(al6, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r10 = (w << 16) | (u & 0xffff);

                    u = ((imul(al6, bl5)|0) + (m & 0xffff)|0) + (r11 & 0xffff)|0;
                    v = ((imul(ah6, bl5)|0) + (m >>> 16)|0) + (r11 >>> 16)|0;
                    w = ((imul(al6, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r11 = (w << 16) | (u & 0xffff);

                    u = ((imul(al6, bl6)|0) + (m & 0xffff)|0) + (r12 & 0xffff)|0;
                    v = ((imul(ah6, bl6)|0) + (m >>> 16)|0) + (r12 >>> 16)|0;
                    w = ((imul(al6, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r12 = (w << 16) | (u & 0xffff);

                    u = ((imul(al6, bl7)|0) + (m & 0xffff)|0) + (r13 & 0xffff)|0;
                    v = ((imul(ah6, bl7)|0) + (m >>> 16)|0) + (r13 >>> 16)|0;
                    w = ((imul(al6, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah6, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r13 = (w << 16) | (u & 0xffff);

                    r14 = m;

                    u = ((imul(al7, bl0)|0) + (r15 & 0xffff)|0) + (r7 & 0xffff)|0;
                    v = ((imul(ah7, bl0)|0) + (r15 >>> 16)|0) + (r7 >>> 16)|0;
                    w = ((imul(al7, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r7 = (w << 16) | (u & 0xffff);

                    u = ((imul(al7, bl1)|0) + (m & 0xffff)|0) + (r8 & 0xffff)|0;
                    v = ((imul(ah7, bl1)|0) + (m >>> 16)|0) + (r8 >>> 16)|0;
                    w = ((imul(al7, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r8 = (w << 16) | (u & 0xffff);

                    u = ((imul(al7, bl2)|0) + (m & 0xffff)|0) + (r9 & 0xffff)|0;
                    v = ((imul(ah7, bl2)|0) + (m >>> 16)|0) + (r9 >>> 16)|0;
                    w = ((imul(al7, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r9 = (w << 16) | (u & 0xffff);

                    u = ((imul(al7, bl3)|0) + (m & 0xffff)|0) + (r10 & 0xffff)|0;
                    v = ((imul(ah7, bl3)|0) + (m >>> 16)|0) + (r10 >>> 16)|0;
                    w = ((imul(al7, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r10 = (w << 16) | (u & 0xffff);

                    u = ((imul(al7, bl4)|0) + (m & 0xffff)|0) + (r11 & 0xffff)|0;
                    v = ((imul(ah7, bl4)|0) + (m >>> 16)|0) + (r11 >>> 16)|0;
                    w = ((imul(al7, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r11 = (w << 16) | (u & 0xffff);

                    u = ((imul(al7, bl5)|0) + (m & 0xffff)|0) + (r12 & 0xffff)|0;
                    v = ((imul(ah7, bl5)|0) + (m >>> 16)|0) + (r12 >>> 16)|0;
                    w = ((imul(al7, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r12 = (w << 16) | (u & 0xffff);

                    u = ((imul(al7, bl6)|0) + (m & 0xffff)|0) + (r13 & 0xffff)|0;
                    v = ((imul(ah7, bl6)|0) + (m >>> 16)|0) + (r13 >>> 16)|0;
                    w = ((imul(al7, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r13 = (w << 16) | (u & 0xffff);

                    u = ((imul(al7, bl7)|0) + (m & 0xffff)|0) + (r14 & 0xffff)|0;
                    v = ((imul(ah7, bl7)|0) + (m >>> 16)|0) + (r14 >>> 16)|0;
                    w = ((imul(al7, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah7, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r14 = (w << 16) | (u & 0xffff);

                    r15 = m;

                    HEAP32[(Rk|0)>>2] = r0,
                    HEAP32[(Rk|4)>>2] = r1,
                    HEAP32[(Rk|8)>>2] = r2,
                    HEAP32[(Rk|12)>>2] = r3,
                    HEAP32[(Rk|16)>>2] = r4,
                    HEAP32[(Rk|20)>>2] = r5,
                    HEAP32[(Rk|24)>>2] = r6,
                    HEAP32[(Rk|28)>>2] = r7;
                }

                Rk = (R+(i+j|0))|0;
                HEAP32[(Rk|0)>>2] = r8,
                HEAP32[(Rk|4)>>2] = r9,
                HEAP32[(Rk|8)>>2] = r10,
                HEAP32[(Rk|12)>>2] = r11,
                HEAP32[(Rk|16)>>2] = r12,
                HEAP32[(Rk|20)>>2] = r13,
                HEAP32[(Rk|24)>>2] = r14,
                HEAP32[(Rk|28)>>2] = r15;
            }
    /*
            for ( i = lA & -32; (i|0) < (lA|0); i = (i+4)|0 ) {
                Ai = (A+i)|0;

                ah0 = HEAP32[Ai>>2]|0,
                al0 = ah0 & 0xffff,
                ah0 = ah0 >>> 16;

                r1 = 0;

                for ( j = 0; (j|0) < (lB|0); j = (j+4)|0 ) {
                    Bj = (B+j)|0;
                    Rk = (R+(i+j|0))|0;

                    bh0 = HEAP32[Bj>>2]|0,
                    bl0 = bh0 & 0xffff,
                    bh0 = bh0 >>> 16;

                    r0 = HEAP32[Rk>>2]|0;

                    u = ((imul(al0, bl0)|0) + (r1 & 0xffff)|0) + (r0 & 0xffff)|0;
                    v = ((imul(ah0, bl0)|0) + (r1 >>> 16)|0) + (r0 >>> 16)|0;
                    w = ((imul(al0, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                    m = ((imul(ah0, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                    r0 = (w << 16) | (u & 0xffff);

                    r1 = m;

                    HEAP32[Rk>>2] = r0;
                }

                Rk = (R+(i+j|0))|0;
                HEAP32[Rk>>2] = r1;
            }
    */
        }

        /**
         * Fast squaring
         *
         * Exploits the fact:
         *
         *  X² = ( X0 + X1*B )² = X0² + 2*X0*X1*B + X1²*B²,
         *
         * where B is a power of 2, so:
         *
         *  2*X0*X1*B = (X0*X1 << 1)*B
         *
         * @param A offset of the argument being squared, 32-byte aligned
         * @param lA length of the argument, multiple of 32
         *
         * @param R offset where to place the result to, 32-byte aligned
         */
        function sqr ( A, lA, R ) {
            A  =  A|0;
            lA = lA|0;
            R  =  R|0;

            var al0 = 0, al1 = 0, al2 = 0, al3 = 0, al4 = 0, al5 = 0, al6 = 0, al7 = 0, ah0 = 0, ah1 = 0, ah2 = 0, ah3 = 0, ah4 = 0, ah5 = 0, ah6 = 0, ah7 = 0,
                bl0 = 0, bl1 = 0, bl2 = 0, bl3 = 0, bl4 = 0, bl5 = 0, bl6 = 0, bl7 = 0, bh0 = 0, bh1 = 0, bh2 = 0, bh3 = 0, bh4 = 0, bh5 = 0, bh6 = 0, bh7 = 0,
                r0 = 0, r1 = 0, r2 = 0, r3 = 0, r4 = 0, r5 = 0, r6 = 0, r7 = 0, r8 = 0, r9 = 0, r10 = 0, r11 = 0, r12 = 0, r13 = 0, r14 = 0, r15 = 0,
                u = 0, v = 0, w = 0, c = 0, h = 0, m = 0, r = 0,
                d = 0, dd = 0, p = 0, i = 0, j = 0, k = 0, Ai = 0, Aj = 0, Rk = 0;

            // prepare for iterations
            for ( ; (i|0) < (lA|0); i = (i+4)|0 ) {
                Rk = R+(i<<1)|0;
                ah0 = HEAP32[(A+i)>>2]|0, al0 = ah0 & 0xffff, ah0 = ah0 >>> 16;
                u = imul(al0,al0)|0;
                v = (imul(al0,ah0)|0) + (u >>> 17)|0;
                w = (imul(ah0,ah0)|0) + (v >>> 15)|0;
                HEAP32[(Rk)>>2] = (v << 17) | (u & 0x1ffff);
                HEAP32[(Rk|4)>>2] = w;
            }

            // unrolled 1st iteration
            for ( p = 0; (p|0) < (lA|0); p = (p+8)|0 ) {
                Ai = A+p|0, Rk = R+(p<<1)|0;

                ah0 = HEAP32[(Ai)>>2]|0, al0 = ah0 & 0xffff, ah0 = ah0 >>> 16;

                bh0 = HEAP32[(Ai|4)>>2]|0, bl0 = bh0 & 0xffff, bh0 = bh0 >>> 16;

                u = imul(al0,bl0)|0;
                v = (imul(al0,bh0)|0) + (u >>> 16)|0;
                w = (imul(ah0,bl0)|0) + (v & 0xffff)|0;
                m = ((imul(ah0,bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;

                r = HEAP32[(Rk|4)>>2]|0;
                u = (r & 0xffff) + ((u & 0xffff) << 1)|0;
                w = ((r >>> 16) + ((w & 0xffff) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|4)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk|8)>>2]|0;
                u = ((r & 0xffff) + ((m & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((m >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|8)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                if ( c ) {
                    r = HEAP32[(Rk|12)>>2]|0;
                    u = (r & 0xffff) + c|0;
                    w = (r >>> 16) + (u >>> 16)|0;
                    HEAP32[(Rk|12)>>2] = (w << 16) | (u & 0xffff);
                }
            }

            // unrolled 2nd iteration
            for ( p = 0; (p|0) < (lA|0); p = (p+16)|0 ) {
                Ai = A+p|0, Rk = R+(p<<1)|0;

                ah0 = HEAP32[(Ai)>>2]|0, al0 = ah0 & 0xffff, ah0 = ah0 >>> 16,
                ah1 = HEAP32[(Ai|4)>>2]|0, al1 = ah1 & 0xffff, ah1 = ah1 >>> 16;

                bh0 = HEAP32[(Ai|8)>>2]|0, bl0 = bh0 & 0xffff, bh0 = bh0 >>> 16,
                bh1 = HEAP32[(Ai|12)>>2]|0, bl1 = bh1 & 0xffff, bh1 = bh1 >>> 16;

                u = imul(al0, bl0)|0;
                v = imul(ah0, bl0)|0;
                w = ((imul(al0, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah0, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r0 = (w << 16) | (u & 0xffff);

                u = (imul(al0, bl1)|0) + (m & 0xffff)|0;
                v = (imul(ah0, bl1)|0) + (m >>> 16)|0;
                w = ((imul(al0, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah0, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r1 = (w << 16) | (u & 0xffff);

                r2 = m;

                u = (imul(al1, bl0)|0) + (r1 & 0xffff)|0;
                v = (imul(ah1, bl0)|0) + (r1 >>> 16)|0;
                w = ((imul(al1, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah1, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r1 = (w << 16) | (u & 0xffff);

                u = ((imul(al1, bl1)|0) + (r2 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah1, bl1)|0) + (r2 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al1, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah1, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r2 = (w << 16) | (u & 0xffff);

                r3 = m;

                r = HEAP32[(Rk|8)>>2]|0;
                u = (r & 0xffff) + ((r0 & 0xffff) << 1)|0;
                w = ((r >>> 16) + ((r0 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|8)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk|12)>>2]|0;
                u = ((r & 0xffff) + ((r1 & 0xffff) << 1)|0)  + c|0;
                w = ((r >>> 16) + ((r1 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|12)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk|16)>>2]|0;
                u = ((r & 0xffff) + ((r2 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r2 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|16)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk|20)>>2]|0;
                u = ((r & 0xffff) + ((r3 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r3 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|20)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                for ( k = 24; !!c & ( (k|0) < 32 ); k = (k+4)|0 ) {
                    r = HEAP32[(Rk|k)>>2]|0;
                    u = (r & 0xffff) + c|0;
                    w = (r >>> 16) + (u >>> 16)|0;
                    HEAP32[(Rk|k)>>2] = (w << 16) | (u & 0xffff);
                    c = w >>> 16;
                }
            }

            // unrolled 3rd iteration
            for ( p = 0; (p|0) < (lA|0); p = (p+32)|0 ) {
                Ai = A+p|0, Rk = R+(p<<1)|0;

                ah0 = HEAP32[(Ai)>>2]|0, al0 = ah0 & 0xffff, ah0 = ah0 >>> 16,
                ah1 = HEAP32[(Ai|4)>>2]|0, al1 = ah1 & 0xffff, ah1 = ah1 >>> 16,
                ah2 = HEAP32[(Ai|8)>>2]|0, al2 = ah2 & 0xffff, ah2 = ah2 >>> 16,
                ah3 = HEAP32[(Ai|12)>>2]|0, al3 = ah3 & 0xffff, ah3 = ah3 >>> 16;

                bh0 = HEAP32[(Ai|16)>>2]|0, bl0 = bh0 & 0xffff, bh0 = bh0 >>> 16,
                bh1 = HEAP32[(Ai|20)>>2]|0, bl1 = bh1 & 0xffff, bh1 = bh1 >>> 16,
                bh2 = HEAP32[(Ai|24)>>2]|0, bl2 = bh2 & 0xffff, bh2 = bh2 >>> 16,
                bh3 = HEAP32[(Ai|28)>>2]|0, bl3 = bh3 & 0xffff, bh3 = bh3 >>> 16;

                u = imul(al0, bl0)|0;
                v = imul(ah0, bl0)|0;
                w = ((imul(al0, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah0, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r0 = (w << 16) | (u & 0xffff);

                u = (imul(al0, bl1)|0) + (m & 0xffff)|0;
                v = (imul(ah0, bl1)|0) + (m >>> 16)|0;
                w = ((imul(al0, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah0, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r1 = (w << 16) | (u & 0xffff);

                u = (imul(al0, bl2)|0) + (m & 0xffff)|0;
                v = (imul(ah0, bl2)|0) + (m >>> 16)|0;
                w = ((imul(al0, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah0, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r2 = (w << 16) | (u & 0xffff);

                u = (imul(al0, bl3)|0) + (m & 0xffff)|0;
                v = (imul(ah0, bl3)|0) + (m >>> 16)|0;
                w = ((imul(al0, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah0, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r3 = (w << 16) | (u & 0xffff);

                r4 = m;

                u = (imul(al1, bl0)|0) + (r1 & 0xffff)|0;
                v = (imul(ah1, bl0)|0) + (r1 >>> 16)|0;
                w = ((imul(al1, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah1, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r1 = (w << 16) | (u & 0xffff);

                u = ((imul(al1, bl1)|0) + (r2 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah1, bl1)|0) + (r2 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al1, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah1, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r2 = (w << 16) | (u & 0xffff);

                u = ((imul(al1, bl2)|0) + (r3 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah1, bl2)|0) + (r3 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al1, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah1, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r3 = (w << 16) | (u & 0xffff);

                u = ((imul(al1, bl3)|0) + (r4 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah1, bl3)|0) + (r4 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al1, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah1, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r4 = (w << 16) | (u & 0xffff);

                r5 = m;

                u = (imul(al2, bl0)|0) + (r2 & 0xffff)|0;
                v = (imul(ah2, bl0)|0) + (r2 >>> 16)|0;
                w = ((imul(al2, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah2, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r2 = (w << 16) | (u & 0xffff);

                u = ((imul(al2, bl1)|0) + (r3 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah2, bl1)|0) + (r3 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al2, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah2, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r3 = (w << 16) | (u & 0xffff);

                u = ((imul(al2, bl2)|0) + (r4 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah2, bl2)|0) + (r4 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al2, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah2, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r4 = (w << 16) | (u & 0xffff);

                u = ((imul(al2, bl3)|0) + (r5 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah2, bl3)|0) + (r5 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al2, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah2, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r5 = (w << 16) | (u & 0xffff);

                r6 = m;

                u = (imul(al3, bl0)|0) + (r3 & 0xffff)|0;
                v = (imul(ah3, bl0)|0) + (r3 >>> 16)|0;
                w = ((imul(al3, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah3, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r3 = (w << 16) | (u & 0xffff);

                u = ((imul(al3, bl1)|0) + (r4 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah3, bl1)|0) + (r4 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al3, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah3, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r4 = (w << 16) | (u & 0xffff);

                u = ((imul(al3, bl2)|0) + (r5 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah3, bl2)|0) + (r5 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al3, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah3, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r5 = (w << 16) | (u & 0xffff);

                u = ((imul(al3, bl3)|0) + (r6 & 0xffff)|0) + (m & 0xffff)|0;
                v = ((imul(ah3, bl3)|0) + (r6 >>> 16)|0) + (m >>> 16)|0;
                w = ((imul(al3, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                m = ((imul(ah3, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                r6 = (w << 16) | (u & 0xffff);

                r7 = m;

                r = HEAP32[(Rk|16)>>2]|0;
                u = (r & 0xffff) + ((r0 & 0xffff) << 1)|0;
                w = ((r >>> 16) + ((r0 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|16)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk|20)>>2]|0;
                u = ((r & 0xffff) + ((r1 & 0xffff) << 1)|0)  + c|0;
                w = ((r >>> 16) + ((r1 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|20)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk|24)>>2]|0;
                u = ((r & 0xffff) + ((r2 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r2 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|24)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk|28)>>2]|0;
                u = ((r & 0xffff) + ((r3 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r3 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk|28)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk+32)>>2]|0;
                u = ((r & 0xffff) + ((r4 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r4 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk+32)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk+36)>>2]|0;
                u = ((r & 0xffff) + ((r5 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r5 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk+36)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk+40)>>2]|0;
                u = ((r & 0xffff) + ((r6 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r6 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk+40)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                r = HEAP32[(Rk+44)>>2]|0;
                u = ((r & 0xffff) + ((r7 & 0xffff) << 1)|0) + c|0;
                w = ((r >>> 16) + ((r7 >>> 16) << 1)|0) + (u >>> 16)|0;
                HEAP32[(Rk+44)>>2] = (w << 16) | (u & 0xffff);
                c = w >>> 16;

                for ( k = 48; !!c & ( (k|0) < 64 ); k = (k+4)|0 ) {
                    r = HEAP32[(Rk+k)>>2]|0;
                    u = (r & 0xffff) + c|0;
                    w = (r >>> 16) + (u >>> 16)|0;
                    HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                    c = w >>> 16;
                }
            }

            // perform iterations
            for ( d = 32; (d|0) < (lA|0); d = d << 1 ) { // depth loop
                dd = d << 1;

                for ( p = 0; (p|0) < (lA|0); p = (p+dd)|0 ) { // part loop
                    Rk = R+(p<<1)|0;

                    h = 0;
                    for ( i = 0; (i|0) < (d|0); i = (i+32)|0 ) { // multiply-and-add loop
                        Ai = (A+p|0)+i|0;

                        ah0 = HEAP32[(Ai)>>2]|0, al0 = ah0 & 0xffff, ah0 = ah0 >>> 16,
                        ah1 = HEAP32[(Ai|4)>>2]|0, al1 = ah1 & 0xffff, ah1 = ah1 >>> 16,
                        ah2 = HEAP32[(Ai|8)>>2]|0, al2 = ah2 & 0xffff, ah2 = ah2 >>> 16,
                        ah3 = HEAP32[(Ai|12)>>2]|0, al3 = ah3 & 0xffff, ah3 = ah3 >>> 16,
                        ah4 = HEAP32[(Ai|16)>>2]|0, al4 = ah4 & 0xffff, ah4 = ah4 >>> 16,
                        ah5 = HEAP32[(Ai|20)>>2]|0, al5 = ah5 & 0xffff, ah5 = ah5 >>> 16,
                        ah6 = HEAP32[(Ai|24)>>2]|0, al6 = ah6 & 0xffff, ah6 = ah6 >>> 16,
                        ah7 = HEAP32[(Ai|28)>>2]|0, al7 = ah7 & 0xffff, ah7 = ah7 >>> 16;

                        r8 = r9 = r10 = r11 = r12 = r13 = r14 = r15 = c = 0;

                        for ( j = 0; (j|0) < (d|0); j = (j+32)|0 ) {
                            Aj = ((A+p|0)+d|0)+j|0;

                            bh0 = HEAP32[(Aj)>>2]|0, bl0 = bh0 & 0xffff, bh0 = bh0 >>> 16,
                            bh1 = HEAP32[(Aj|4)>>2]|0, bl1 = bh1 & 0xffff, bh1 = bh1 >>> 16,
                            bh2 = HEAP32[(Aj|8)>>2]|0, bl2 = bh2 & 0xffff, bh2 = bh2 >>> 16,
                            bh3 = HEAP32[(Aj|12)>>2]|0, bl3 = bh3 & 0xffff, bh3 = bh3 >>> 16,
                            bh4 = HEAP32[(Aj|16)>>2]|0, bl4 = bh4 & 0xffff, bh4 = bh4 >>> 16,
                            bh5 = HEAP32[(Aj|20)>>2]|0, bl5 = bh5 & 0xffff, bh5 = bh5 >>> 16,
                            bh6 = HEAP32[(Aj|24)>>2]|0, bl6 = bh6 & 0xffff, bh6 = bh6 >>> 16,
                            bh7 = HEAP32[(Aj|28)>>2]|0, bl7 = bh7 & 0xffff, bh7 = bh7 >>> 16;

                            r0 = r1 = r2 = r3 = r4 = r5 = r6 = r7 = 0;

                            u = ((imul(al0, bl0)|0) + (r0 & 0xffff)|0) + (r8 & 0xffff)|0;
                            v = ((imul(ah0, bl0)|0) + (r0 >>> 16)|0) + (r8 >>> 16)|0;
                            w = ((imul(al0, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r0 = (w << 16) | (u & 0xffff);

                            u = ((imul(al0, bl1)|0) + (r1 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah0, bl1)|0) + (r1 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al0, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r1 = (w << 16) | (u & 0xffff);

                            u = ((imul(al0, bl2)|0) + (r2 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah0, bl2)|0) + (r2 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al0, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r2 = (w << 16) | (u & 0xffff);

                            u = ((imul(al0, bl3)|0) + (r3 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah0, bl3)|0) + (r3 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al0, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r3 = (w << 16) | (u & 0xffff);

                            u = ((imul(al0, bl4)|0) + (r4 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah0, bl4)|0) + (r4 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al0, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r4 = (w << 16) | (u & 0xffff);

                            u = ((imul(al0, bl5)|0) + (r5 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah0, bl5)|0) + (r5 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al0, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r5 = (w << 16) | (u & 0xffff);

                            u = ((imul(al0, bl6)|0) + (r6 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah0, bl6)|0) + (r6 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al0, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r6 = (w << 16) | (u & 0xffff);

                            u = ((imul(al0, bl7)|0) + (r7 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah0, bl7)|0) + (r7 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al0, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah0, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            r8 = m;

                            u = ((imul(al1, bl0)|0) + (r1 & 0xffff)|0) + (r9 & 0xffff)|0;
                            v = ((imul(ah1, bl0)|0) + (r1 >>> 16)|0) + (r9 >>> 16)|0;
                            w = ((imul(al1, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r1 = (w << 16) | (u & 0xffff);

                            u = ((imul(al1, bl1)|0) + (r2 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah1, bl1)|0) + (r2 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al1, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r2 = (w << 16) | (u & 0xffff);

                            u = ((imul(al1, bl2)|0) + (r3 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah1, bl2)|0) + (r3 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al1, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r3 = (w << 16) | (u & 0xffff);

                            u = ((imul(al1, bl3)|0) + (r4 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah1, bl3)|0) + (r4 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al1, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r4 = (w << 16) | (u & 0xffff);

                            u = ((imul(al1, bl4)|0) + (r5 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah1, bl4)|0) + (r5 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al1, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r5 = (w << 16) | (u & 0xffff);

                            u = ((imul(al1, bl5)|0) + (r6 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah1, bl5)|0) + (r6 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al1, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r6 = (w << 16) | (u & 0xffff);

                            u = ((imul(al1, bl6)|0) + (r7 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah1, bl6)|0) + (r7 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al1, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            u = ((imul(al1, bl7)|0) + (r8 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah1, bl7)|0) + (r8 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al1, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah1, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r8 = (w << 16) | (u & 0xffff);

                            r9 = m;

                            u = ((imul(al2, bl0)|0) + (r2 & 0xffff)|0) + (r10 & 0xffff)|0;
                            v = ((imul(ah2, bl0)|0) + (r2 >>> 16)|0) + (r10 >>> 16)|0;
                            w = ((imul(al2, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r2 = (w << 16) | (u & 0xffff);

                            u = ((imul(al2, bl1)|0) + (r3 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah2, bl1)|0) + (r3 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al2, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r3 = (w << 16) | (u & 0xffff);

                            u = ((imul(al2, bl2)|0) + (r4 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah2, bl2)|0) + (r4 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al2, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r4 = (w << 16) | (u & 0xffff);

                            u = ((imul(al2, bl3)|0) + (r5 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah2, bl3)|0) + (r5 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al2, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r5 = (w << 16) | (u & 0xffff);

                            u = ((imul(al2, bl4)|0) + (r6 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah2, bl4)|0) + (r6 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al2, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r6 = (w << 16) | (u & 0xffff);

                            u = ((imul(al2, bl5)|0) + (r7 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah2, bl5)|0) + (r7 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al2, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            u = ((imul(al2, bl6)|0) + (r8 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah2, bl6)|0) + (r8 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al2, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r8 = (w << 16) | (u & 0xffff);

                            u = ((imul(al2, bl7)|0) + (r9 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah2, bl7)|0) + (r9 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al2, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah2, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r9 = (w << 16) | (u & 0xffff);

                            r10 = m;

                            u = ((imul(al3, bl0)|0) + (r3 & 0xffff)|0) + (r11 & 0xffff)|0;
                            v = ((imul(ah3, bl0)|0) + (r3 >>> 16)|0) + (r11 >>> 16)|0;
                            w = ((imul(al3, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r3 = (w << 16) | (u & 0xffff);

                            u = ((imul(al3, bl1)|0) + (r4 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah3, bl1)|0) + (r4 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al3, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r4 = (w << 16) | (u & 0xffff);

                            u = ((imul(al3, bl2)|0) + (r5 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah3, bl2)|0) + (r5 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al3, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r5 = (w << 16) | (u & 0xffff);

                            u = ((imul(al3, bl3)|0) + (r6 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah3, bl3)|0) + (r6 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al3, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r6 = (w << 16) | (u & 0xffff);

                            u = ((imul(al3, bl4)|0) + (r7 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah3, bl4)|0) + (r7 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al3, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            u = ((imul(al3, bl5)|0) + (r8 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah3, bl5)|0) + (r8 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al3, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r8 = (w << 16) | (u & 0xffff);

                            u = ((imul(al3, bl6)|0) + (r9 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah3, bl6)|0) + (r9 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al3, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r9 = (w << 16) | (u & 0xffff);

                            u = ((imul(al3, bl7)|0) + (r10 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah3, bl7)|0) + (r10 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al3, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah3, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r10 = (w << 16) | (u & 0xffff);

                            r11 = m;

                            u = ((imul(al4, bl0)|0) + (r4 & 0xffff)|0) + (r12 & 0xffff)|0;
                            v = ((imul(ah4, bl0)|0) + (r4 >>> 16)|0) + (r12 >>> 16)|0;
                            w = ((imul(al4, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r4 = (w << 16) | (u & 0xffff);

                            u = ((imul(al4, bl1)|0) + (r5 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah4, bl1)|0) + (r5 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al4, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r5 = (w << 16) | (u & 0xffff);

                            u = ((imul(al4, bl2)|0) + (r6 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah4, bl2)|0) + (r6 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al4, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r6 = (w << 16) | (u & 0xffff);

                            u = ((imul(al4, bl3)|0) + (r7 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah4, bl3)|0) + (r7 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al4, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            u = ((imul(al4, bl4)|0) + (r8 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah4, bl4)|0) + (r8 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al4, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r8 = (w << 16) | (u & 0xffff);

                            u = ((imul(al4, bl5)|0) + (r9 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah4, bl5)|0) + (r9 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al4, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r9 = (w << 16) | (u & 0xffff);

                            u = ((imul(al4, bl6)|0) + (r10 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah4, bl6)|0) + (r10 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al4, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r10 = (w << 16) | (u & 0xffff);

                            u = ((imul(al4, bl7)|0) + (r11 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah4, bl7)|0) + (r11 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al4, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah4, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r11 = (w << 16) | (u & 0xffff);

                            r12 = m;

                            u = ((imul(al5, bl0)|0) + (r5 & 0xffff)|0) + (r13 & 0xffff)|0;
                            v = ((imul(ah5, bl0)|0) + (r5 >>> 16)|0) + (r13 >>> 16)|0;
                            w = ((imul(al5, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r5 = (w << 16) | (u & 0xffff);

                            u = ((imul(al5, bl1)|0) + (r6 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah5, bl1)|0) + (r6 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al5, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r6 = (w << 16) | (u & 0xffff);

                            u = ((imul(al5, bl2)|0) + (r7 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah5, bl2)|0) + (r7 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al5, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            u = ((imul(al5, bl3)|0) + (r8 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah5, bl3)|0) + (r8 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al5, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r8 = (w << 16) | (u & 0xffff);

                            u = ((imul(al5, bl4)|0) + (r9 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah5, bl4)|0) + (r9 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al5, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r9 = (w << 16) | (u & 0xffff);

                            u = ((imul(al5, bl5)|0) + (r10 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah5, bl5)|0) + (r10 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al5, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r10 = (w << 16) | (u & 0xffff);

                            u = ((imul(al5, bl6)|0) + (r11 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah5, bl6)|0) + (r11 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al5, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r11 = (w << 16) | (u & 0xffff);

                            u = ((imul(al5, bl7)|0) + (r12 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah5, bl7)|0) + (r12 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al5, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah5, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r12 = (w << 16) | (u & 0xffff);

                            r13 = m;

                            u = ((imul(al6, bl0)|0) + (r6 & 0xffff)|0) + (r14 & 0xffff)|0;
                            v = ((imul(ah6, bl0)|0) + (r6 >>> 16)|0) + (r14 >>> 16)|0;
                            w = ((imul(al6, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r6 = (w << 16) | (u & 0xffff);

                            u = ((imul(al6, bl1)|0) + (r7 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah6, bl1)|0) + (r7 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al6, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            u = ((imul(al6, bl2)|0) + (r8 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah6, bl2)|0) + (r8 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al6, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r8 = (w << 16) | (u & 0xffff);

                            u = ((imul(al6, bl3)|0) + (r9 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah6, bl3)|0) + (r9 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al6, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r9 = (w << 16) | (u & 0xffff);

                            u = ((imul(al6, bl4)|0) + (r10 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah6, bl4)|0) + (r10 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al6, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r10 = (w << 16) | (u & 0xffff);

                            u = ((imul(al6, bl5)|0) + (r11 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah6, bl5)|0) + (r11 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al6, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r11 = (w << 16) | (u & 0xffff);

                            u = ((imul(al6, bl6)|0) + (r12 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah6, bl6)|0) + (r12 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al6, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r12 = (w << 16) | (u & 0xffff);

                            u = ((imul(al6, bl7)|0) + (r13 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah6, bl7)|0) + (r13 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al6, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah6, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r13 = (w << 16) | (u & 0xffff);

                            r14 = m;

                            u = ((imul(al7, bl0)|0) + (r7 & 0xffff)|0) + (r15 & 0xffff)|0;
                            v = ((imul(ah7, bl0)|0) + (r7 >>> 16)|0) + (r15 >>> 16)|0;
                            w = ((imul(al7, bh0)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh0)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r7 = (w << 16) | (u & 0xffff);

                            u = ((imul(al7, bl1)|0) + (r8 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah7, bl1)|0) + (r8 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al7, bh1)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh1)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r8 = (w << 16) | (u & 0xffff);

                            u = ((imul(al7, bl2)|0) + (r9 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah7, bl2)|0) + (r9 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al7, bh2)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh2)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r9 = (w << 16) | (u & 0xffff);

                            u = ((imul(al7, bl3)|0) + (r10 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah7, bl3)|0) + (r10 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al7, bh3)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh3)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r10 = (w << 16) | (u & 0xffff);

                            u = ((imul(al7, bl4)|0) + (r11 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah7, bl4)|0) + (r11 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al7, bh4)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh4)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r11 = (w << 16) | (u & 0xffff);

                            u = ((imul(al7, bl5)|0) + (r12 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah7, bl5)|0) + (r12 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al7, bh5)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh5)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r12 = (w << 16) | (u & 0xffff);

                            u = ((imul(al7, bl6)|0) + (r13 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah7, bl6)|0) + (r13 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al7, bh6)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh6)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r13 = (w << 16) | (u & 0xffff);

                            u = ((imul(al7, bl7)|0) + (r14 & 0xffff)|0) + (m & 0xffff)|0;
                            v = ((imul(ah7, bl7)|0) + (r14 >>> 16)|0) + (m >>> 16)|0;
                            w = ((imul(al7, bh7)|0) + (v & 0xffff)|0) + (u >>> 16)|0;
                            m = ((imul(ah7, bh7)|0) + (v >>> 16)|0) + (w >>> 16)|0;
                            r14 = (w << 16) | (u & 0xffff);

                            r15 = m;

                            k = d+(i+j|0)|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r0 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r0 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;

                            k = k+4|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r1 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r1 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;

                            k = k+4|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r2 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r2 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;

                            k = k+4|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r3 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r3 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;

                            k = k+4|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r4 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r4 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;

                            k = k+4|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r5 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r5 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;

                            k = k+4|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r6 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r6 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;

                            k = k+4|0;
                            r = HEAP32[(Rk+k)>>2]|0;
                            u = ((r & 0xffff) + ((r7 & 0xffff) << 1)|0) + c|0;
                            w = ((r >>> 16) + ((r7 >>> 16) << 1)|0) + (u >>> 16)|0;
                            HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                            c = w >>> 16;
                        }

                        k = d+(i+j|0)|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = (((r & 0xffff) + ((r8 & 0xffff) << 1)|0) + c|0) + h|0;
                        w = ((r >>> 16) + ((r8 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        c = w >>> 16;

                        k = k+4|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = ((r & 0xffff) + ((r9 & 0xffff) << 1)|0) + c|0;
                        w = ((r >>> 16) + ((r9 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        c = w >>> 16;

                        k = k+4|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = ((r & 0xffff) + ((r10 & 0xffff) << 1)|0) + c|0;
                        w = ((r >>> 16) + ((r10 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        c = w >>> 16;

                        k = k+4|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = ((r & 0xffff) + ((r11 & 0xffff) << 1)|0) + c|0;
                        w = ((r >>> 16) + ((r11 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        c = w >>> 16;

                        k = k+4|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = ((r & 0xffff) + ((r12 & 0xffff) << 1)|0) + c|0;
                        w = ((r >>> 16) + ((r12 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        c = w >>> 16;

                        k = k+4|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = ((r & 0xffff) + ((r13 & 0xffff) << 1)|0) + c|0;
                        w = ((r >>> 16) + ((r13 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        c = w >>> 16;

                        k = k+4|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = ((r & 0xffff) + ((r14 & 0xffff) << 1)|0) + c|0;
                        w = ((r >>> 16) + ((r14 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        c = w >>> 16;

                        k = k+4|0;
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = ((r & 0xffff) + ((r15 & 0xffff) << 1)|0) + c|0;
                        w = ((r >>> 16) + ((r15 >>> 16) << 1)|0) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        h = w >>> 16;
                    }

                    for ( k = k+4|0; !!h & ( (k|0) < (dd<<1) ); k = (k+4)|0 ) { // carry propagation loop
                        r = HEAP32[(Rk+k)>>2]|0;
                        u = (r & 0xffff) + h|0;
                        w = (r >>> 16) + (u >>> 16)|0;
                        HEAP32[(Rk+k)>>2] = (w << 16) | (u & 0xffff);
                        h = w >>> 16;
                    }
                }
            }
        }

        /**
         * Conventional division
         *
         * @param A offset of the numerator, 32-byte aligned
         * @param lA length of the numerator, multiple of 32
         *
         * @param B offset of the divisor, 32-byte aligned
         * @param lB length of the divisor, multiple of 32
         *
         * @param R offset where to place the remainder to, 32-byte aligned
         *
         * @param Q offser where to place the quotient to, 32-byte aligned
         */

        function div ( N, lN, D, lD, Q ) {
            N  =  N|0;
            lN = lN|0;
            D  =  D|0;
            lD = lD|0;
            Q  =  Q|0;

            var n = 0, d = 0, e = 0,
                u1 = 0, u0 = 0,
                v0 = 0, vh = 0, vl = 0,
                qh = 0, ql = 0, rh = 0, rl = 0,
                t1 = 0, t2 = 0, m = 0, c = 0,
                i = 0, j = 0, k = 0;

            // number of significant limbs in `N` (multiplied by 4)
            for ( i = (lN-1) & -4; (i|0) >= 0; i = (i-4)|0 ) {
                n = HEAP32[(N+i)>>2]|0;
                if ( n ) {
                    lN = i;
                    break;
                }
            }

            // number of significant limbs in `D` (multiplied by 4)
            for ( i = (lD-1) & -4; (i|0) >= 0; i = (i-4)|0 ) {
                d = HEAP32[(D+i)>>2]|0;
                if ( d ) {
                    lD = i;
                    break;
                }
            }

            // `D` is zero? WTF?!

            // calculate `e` — the power of 2 of the normalization factor
            while ( (d & 0x80000000) == 0 ) {
                d = d << 1;
                e = e + 1|0;
            }

            // normalize `N` in place
            u0 = HEAP32[(N+lN)>>2]|0;
            if ( e ) {
                u1 = u0>>>(32-e|0);
                for ( i = (lN-4)|0; (i|0) >= 0; i = (i-4)|0 ) {
                    n = HEAP32[(N+i)>>2]|0;
                    HEAP32[(N+i+4)>>2] = (u0 << e) | ( e ? n >>> (32-e|0) : 0 );
                    u0 = n;
                }
                HEAP32[N>>2] = u0 << e;
            }

            // normalize `D` in place
            if ( e ) {
                v0 = HEAP32[(D+lD)>>2]|0;
                for ( i = (lD-4)|0; (i|0) >= 0; i = (i-4)|0 ) {
                    d = HEAP32[(D+i)>>2]|0;
                    HEAP32[(D+i+4)>>2] = (v0 << e) | ( d >>> (32-e|0) );
                    v0 = d;
                }
                HEAP32[D>>2] = v0 << e;
            }

            // divisor parts won't change
            v0 = HEAP32[(D+lD)>>2]|0;
            vh = v0 >>> 16, vl = v0 & 0xffff;

            // perform division
            for ( i = lN; (i|0) >= (lD|0); i = (i-4)|0 ) {
                j = (i-lD)|0;

                // estimate high part of the quotient
                u0 = HEAP32[(N+i)>>2]|0;
                qh = ( (u1>>>0) / (vh>>>0) )|0, rh = ( (u1>>>0) % (vh>>>0) )|0, t1 = imul(qh, vl)|0;
                while ( ( (qh|0) == 0x10000 ) | ( (t1>>>0) > (((rh << 16)|(u0 >>> 16))>>>0) ) ) {
                    qh = (qh-1)|0, rh = (rh+vh)|0, t1 = (t1-vl)|0;
                    if ( (rh|0) >= 0x10000 ) break;
                }

                // bulk multiply-and-subtract
                // m - multiplication carry, c - subtraction carry
                m = 0, c = 0;
                for ( k = 0; (k|0) <= (lD|0); k = (k+4)|0 ) {
                    d = HEAP32[(D+k)>>2]|0;
                    t1 = (imul(qh, d & 0xffff)|0) + (m >>> 16)|0;
                    t2 = (imul(qh, d >>> 16)|0) + (t1 >>> 16)|0;
                    d = (m & 0xffff) | (t1 << 16);
                    m = t2;
                    n = HEAP32[(N+j+k)>>2]|0;
                    t1 = ((n & 0xffff) - (d & 0xffff)|0) + c|0;
                    t2 = ((n >>> 16) - (d >>> 16)|0) + (t1 >> 16)|0;
                    HEAP32[(N+j+k)>>2] = (t2 << 16) | (t1 & 0xffff);
                    c = t2 >> 16;
                }
                t1 = ((u1 & 0xffff) - (m & 0xffff)|0) + c|0;
                t2 = ((u1 >>> 16) - (m >>> 16)|0) + (t1 >> 16)|0;
                u1 = (t2 << 16) | (t1 & 0xffff);
                c = t2 >> 16;

                // add `D` back if got carry-out
                if ( c ) {
                    qh = (qh-1)|0;
                    c = 0;
                    for ( k = 0; (k|0) <= (lD|0); k = (k+4)|0 ) {
                        d = HEAP32[(D+k)>>2]|0;
                        n = HEAP32[(N+j+k)>>2]|0;
                        t1 = (n & 0xffff) + c|0;
                        t2 = (n >>> 16) + d + (t1 >>> 16)|0;
                        HEAP32[(N+j+k)>>2] = (t2 << 16) | (t1 & 0xffff);
                        c = t2 >>> 16;
                    }
                    u1 = (u1+c)|0;
                }

                // estimate low part of the quotient
                u0 = HEAP32[(N+i)>>2]|0;
                n = (u1 << 16) | (u0 >>> 16);
                ql = ( (n>>>0) / (vh>>>0) )|0, rl = ( (n>>>0) % (vh>>>0) )|0, t1 = imul(ql, vl)|0;
                while ( ( (ql|0) == 0x10000 ) | ( (t1>>>0) > (((rl << 16)|(u0 & 0xffff))>>>0) ) ) {
                    ql = (ql-1)|0, rl = (rl+vh)|0, t1 = (t1-vl)|0;
                    if ( (rl|0) >= 0x10000 ) break;
                }

                // bulk multiply-and-subtract
                // m - multiplication carry, c - subtraction carry
                m = 0, c = 0;
                for ( k = 0; (k|0) <= (lD|0); k = (k+4)|0 ) {
                    d = HEAP32[(D+k)>>2]|0;
                    t1 = (imul(ql, d & 0xffff)|0) + (m & 0xffff)|0;
                    t2 = ((imul(ql, d >>> 16)|0) + (t1 >>> 16)|0) + (m >>> 16)|0;
                    d = (t1 & 0xffff) | (t2 << 16);
                    m = t2 >>> 16;
                    n = HEAP32[(N+j+k)>>2]|0;
                    t1 = ((n & 0xffff) - (d & 0xffff)|0) + c|0;
                    t2 = ((n >>> 16) - (d >>> 16)|0) + (t1 >> 16)|0;
                    c = t2 >> 16;
                    HEAP32[(N+j+k)>>2] = (t2 << 16) | (t1 & 0xffff);
                }
                t1 = ((u1 & 0xffff) - (m & 0xffff)|0) + c|0;
                t2 = ((u1 >>> 16) - (m >>> 16)|0) + (t1 >> 16)|0;
                c = t2 >> 16;

                // add `D` back if got carry-out
                if ( c ) {
                    ql = (ql-1)|0;
                    c = 0;
                    for ( k = 0; (k|0) <= (lD|0); k = (k+4)|0 ) {
                        d = HEAP32[(D+k)>>2]|0;
                        n = HEAP32[(N+j+k)>>2]|0;
                        t1 = ((n & 0xffff) + (d & 0xffff)|0) + c|0;
                        t2 = ((n >>> 16) + (d >>> 16)|0) + (t1 >>> 16)|0;
                        c = t2 >>> 16;
                        HEAP32[(N+j+k)>>2] = (t1 & 0xffff) | (t2 << 16);
                    }
                }

                // got quotient limb
                HEAP32[(Q+j)>>2] = (qh << 16) | ql;

                u1 = HEAP32[(N+i)>>2]|0;
            }

            if ( e ) {
                // TODO denormalize `D` in place

                // denormalize `N` in place
                u0 = HEAP32[N>>2]|0;
                for ( i = 4; (i|0) <= (lD|0); i = (i+4)|0 ) {
                    n = HEAP32[(N+i)>>2]|0;
                    HEAP32[(N+i-4)>>2] = ( n << (32-e|0) ) | (u0 >>> e);
                    u0 = n;
                }
                HEAP32[(N+lD)>>2] = u0 >>> e;
            }
        }

        /**
         * Montgomery modular reduction
         *
         * Definition:
         *
         *  MREDC(A) = A × X (mod N),
         *  M × X = N × Y + 1,
         *
         * where M = 2^(32*m) such that N < M and A < N×M
         *
         * Numbers `X` and `Y` can be calculated using Extended Euclidean Algorithm.
         */
        function mredc ( A, lA, N, lN, y, R ) {
            A  =  A|0;
            lA = lA|0;
            N  =  N|0;
            lN = lN|0;
            y  =  y|0;
            R  =  R|0;

            var T = 0,
                c = 0, uh = 0, ul = 0, vl = 0, vh = 0, w0 = 0, w1 = 0, w2 = 0, r0 = 0, r1 = 0,
                i = 0, j = 0, k = 0;

            T = salloc(lN<<1)|0;
            z(lN<<1, 0, T);

            cp( lA, A, T );

            // HAC 14.32
            for ( i = 0; (i|0) < (lN|0); i = (i+4)|0 ) {
                uh = HEAP32[(T+i)>>2]|0, ul = uh & 0xffff, uh = uh >>> 16;
                vh = y >>> 16, vl = y & 0xffff;
                w0 = imul(ul,vl)|0, w1 = ( (imul(ul,vh)|0) + (imul(uh,vl)|0) | 0 ) + (w0 >>> 16) | 0;
                ul = w0 & 0xffff, uh = w1 & 0xffff;
                r1 = 0;
                for ( j = 0; (j|0) < (lN|0); j = (j+4)|0 ) {
                    k = (i+j)|0;
                    vh = HEAP32[(N+j)>>2]|0, vl = vh & 0xffff, vh = vh >>> 16;
                    r0 = HEAP32[(T+k)>>2]|0;
                    w0 = ((imul(ul, vl)|0) + (r1 & 0xffff)|0) + (r0 & 0xffff)|0;
                    w1 = ((imul(ul, vh)|0) + (r1 >>> 16)|0) + (r0 >>> 16)|0;
                    w2 = ((imul(uh, vl)|0) + (w1 & 0xffff)|0) + (w0 >>> 16)|0;
                    r1 = ((imul(uh, vh)|0) + (w2 >>> 16)|0) + (w1 >>> 16)|0;
                    r0 = (w2 << 16) | (w0 & 0xffff);
                    HEAP32[(T+k)>>2] = r0;
                }
                k = (i+j)|0;
                r0 = HEAP32[(T+k)>>2]|0;
                w0 = ((r0 & 0xffff) + (r1 & 0xffff)|0) + c|0;
                w1 = ((r0 >>> 16) + (r1 >>> 16)|0) + (w0 >>> 16)|0;
                HEAP32[(T+k)>>2] = (w1 << 16) | (w0 & 0xffff);
                c = w1 >>> 16;
            }

            cp( lN, (T+lN)|0, R );

            sfree(lN<<1);

            if ( c | ( (cmp( N, lN, R, lN )|0) <= 0 ) ) {
                sub( R, lN, N, lN, R, lN )|0;
            }
        }

        return {
            sreset: sreset,
            salloc: salloc,
            sfree:  sfree,
            z: z,
            tst: tst,
            neg: neg,
            cmp: cmp,
            add: add,
            sub: sub,
            mul: mul,
            sqr: sqr,
            div: div,
            mredc: mredc
        };
    };

    function Number_extGCD(a, b) {
        var sa = a < 0 ? -1 : 1, sb = b < 0 ? -1 : 1, xi = 1, xj = 0, yi = 0, yj = 1, r, q, t, a_cmp_b;
        a *= sa;
        b *= sb;
        a_cmp_b = a < b;
        if (a_cmp_b) {
            t = a;
            (a = b), (b = t);
            t = sa;
            sa = sb;
            sb = t;
        }
        (q = Math.floor(a / b)), (r = a - q * b);
        while (r) {
            (t = xi - q * xj), (xi = xj), (xj = t);
            (t = yi - q * yj), (yi = yj), (yj = t);
            (a = b), (b = r);
            (q = Math.floor(a / b)), (r = a - q * b);
        }
        xj *= sa;
        yj *= sb;
        if (a_cmp_b) {
            t = xj;
            (xj = yj), (yj = t);
        }
        return {
            gcd: b,
            x: xj,
            y: yj,
        };
    }
    function BigNumber_extGCD(a, b) {
        var sa = a.sign;
        var sb = b.sign;
        if (sa < 0)
            a = a.negate();
        if (sb < 0)
            b = b.negate();
        var a_cmp_b = a.compare(b);
        if (a_cmp_b < 0) {
            var t = a;
            (a = b), (b = t);
            var t2 = sa;
            sa = sb;
            sb = t2;
        }
        var xi = BigNumber.ONE, xj = BigNumber.ZERO, lx = b.bitLength, yi = BigNumber.ZERO, yj = BigNumber.ONE, ly = a.bitLength, z, r, q;
        z = a.divide(b);
        while ((r = z.remainder) !== BigNumber.ZERO) {
            q = z.quotient;
            (z = xi.subtract(q.multiply(xj).clamp(lx)).clamp(lx)), (xi = xj), (xj = z);
            (z = yi.subtract(q.multiply(yj).clamp(ly)).clamp(ly)), (yi = yj), (yj = z);
            (a = b), (b = r);
            z = a.divide(b);
        }
        if (sa < 0)
            xj = xj.negate();
        if (sb < 0)
            yj = yj.negate();
        if (a_cmp_b < 0) {
            var t = xj;
            (xj = yj), (yj = t);
        }
        return {
            gcd: b,
            x: xj,
            y: yj,
        };
    }

    function getRandomValues(buf) {
        if (typeof process !== 'undefined') {
            var nodeCrypto = require('crypto');
            var bytes = nodeCrypto.randomBytes(buf.length);
            buf.set(bytes);
            return;
        }
        if (window.crypto && window.crypto.getRandomValues) {
            window.crypto.getRandomValues(buf);
            return;
        }
        if (self.crypto && self.crypto.getRandomValues) {
            self.crypto.getRandomValues(buf);
            return;
        }
        // @ts-ignore
        if (window.msCrypto && window.msCrypto.getRandomValues) {
            // @ts-ignore
            window.msCrypto.getRandomValues(buf);
            return;
        }
        throw new Error('No secure random number generator available.');
    }

    var __extends$1 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    ///////////////////////////////////////////////////////////////////////////////
    var _bigint_stdlib = { Uint32Array: Uint32Array, Math: Math };
    var _bigint_heap = new Uint32Array(0x100000);
    var _bigint_asm;
    function _half_imul(a, b) {
        return (a * b) | 0;
    }
    if (_bigint_stdlib.Math.imul === undefined) {
        _bigint_stdlib.Math.imul = _half_imul;
        _bigint_asm = bigint_asm(_bigint_stdlib, null, _bigint_heap.buffer);
        delete _bigint_stdlib.Math.imul;
    }
    else {
        _bigint_asm = bigint_asm(_bigint_stdlib, null, _bigint_heap.buffer);
    }
    ///////////////////////////////////////////////////////////////////////////////
    var _BigNumber_ZERO_limbs = new Uint32Array(0);
    var BigNumber = /** @class */ (function () {
        function BigNumber(num) {
            var limbs = _BigNumber_ZERO_limbs;
            var bitlen = 0;
            var sign = 0;
            if (num === undefined) ;
            else {
                for (var i = 0; !num[i]; i++)
                    ;
                bitlen = (num.length - i) * 8;
                if (!bitlen)
                    return BigNumber.ZERO;
                limbs = new Uint32Array((bitlen + 31) >> 5);
                for (var j = num.length - 4; j >= i; j -= 4) {
                    limbs[(num.length - 4 - j) >> 2] = (num[j] << 24) | (num[j + 1] << 16) | (num[j + 2] << 8) | num[j + 3];
                }
                if (i - j === 3) {
                    limbs[limbs.length - 1] = num[i];
                }
                else if (i - j === 2) {
                    limbs[limbs.length - 1] = (num[i] << 8) | num[i + 1];
                }
                else if (i - j === 1) {
                    limbs[limbs.length - 1] = (num[i] << 16) | (num[i + 1] << 8) | num[i + 2];
                }
                sign = 1;
            }
            this.limbs = limbs;
            this.bitLength = bitlen;
            this.sign = sign;
        }
        BigNumber.fromString = function (str) {
            var bytes = string_to_bytes(str);
            return new BigNumber(bytes);
        };
        BigNumber.fromNumber = function (num) {
            var limbs = _BigNumber_ZERO_limbs;
            var bitlen = 0;
            var sign = 0;
            var absnum = Math.abs(num);
            if (absnum > 0xffffffff) {
                limbs = new Uint32Array(2);
                limbs[0] = absnum | 0;
                limbs[1] = (absnum / 0x100000000) | 0;
                bitlen = 52;
            }
            else if (absnum > 0) {
                limbs = new Uint32Array(1);
                limbs[0] = absnum;
                bitlen = 32;
            }
            else {
                limbs = _BigNumber_ZERO_limbs;
                bitlen = 0;
            }
            sign = num < 0 ? -1 : 1;
            return BigNumber.fromConfig({ limbs: limbs, bitLength: bitlen, sign: sign });
        };
        BigNumber.fromArrayBuffer = function (buffer) {
            return new BigNumber(new Uint8Array(buffer));
        };
        BigNumber.fromConfig = function (obj) {
            var bn = new BigNumber();
            bn.limbs = new Uint32Array(obj.limbs);
            bn.bitLength = obj.bitLength;
            bn.sign = obj.sign;
            return bn;
        };
        BigNumber.prototype.toString = function (radix) {
            radix = radix || 16;
            var limbs = this.limbs;
            var bitlen = this.bitLength;
            var str = '';
            if (radix === 16) {
                // FIXME clamp last limb to (bitlen % 32)
                for (var i = ((bitlen + 31) >> 5) - 1; i >= 0; i--) {
                    var h = limbs[i].toString(16);
                    str += '00000000'.substr(h.length);
                    str += h;
                }
                str = str.replace(/^0+/, '');
                if (!str.length)
                    str = '0';
            }
            else {
                throw new IllegalArgumentError('bad radix');
            }
            if (this.sign < 0)
                str = '-' + str;
            return str;
        };
        BigNumber.prototype.toBytes = function () {
            var bitlen = this.bitLength;
            var limbs = this.limbs;
            if (bitlen === 0)
                return new Uint8Array(0);
            var bytelen = (bitlen + 7) >> 3;
            var bytes = new Uint8Array(bytelen);
            for (var i = 0; i < bytelen; i++) {
                var j = bytelen - i - 1;
                bytes[i] = limbs[j >> 2] >> ((j & 3) << 3);
            }
            return bytes;
        };
        /**
         * Downgrade to Number
         */
        BigNumber.prototype.valueOf = function () {
            var limbs = this.limbs;
            var bits = this.bitLength;
            var sign = this.sign;
            if (!sign)
                return 0;
            if (bits <= 32)
                return sign * (limbs[0] >>> 0);
            if (bits <= 52)
                return sign * (0x100000000 * (limbs[1] >>> 0) + (limbs[0] >>> 0));
            // normalization
            var i, l, e = 0;
            for (i = limbs.length - 1; i >= 0; i--) {
                if ((l = limbs[i]) === 0)
                    continue;
                while (((l << e) & 0x80000000) === 0)
                    e++;
                break;
            }
            if (i === 0)
                return sign * (limbs[0] >>> 0);
            return (sign *
                (0x100000 * (((limbs[i] << e) | (e ? limbs[i - 1] >>> (32 - e) : 0)) >>> 0) +
                    (((limbs[i - 1] << e) | (e && i > 1 ? limbs[i - 2] >>> (32 - e) : 0)) >>> 12)) *
                Math.pow(2, 32 * i - e - 52));
        };
        BigNumber.prototype.clamp = function (b) {
            var limbs = this.limbs;
            var bitlen = this.bitLength;
            // FIXME check b is number and in a valid range
            if (b >= bitlen)
                return this;
            var clamped = new BigNumber();
            var n = (b + 31) >> 5;
            var k = b % 32;
            clamped.limbs = new Uint32Array(limbs.subarray(0, n));
            clamped.bitLength = b;
            clamped.sign = this.sign;
            if (k)
                clamped.limbs[n - 1] &= -1 >>> (32 - k);
            return clamped;
        };
        BigNumber.prototype.slice = function (f, b) {
            var limbs = this.limbs;
            var bitlen = this.bitLength;
            if (f < 0)
                throw new RangeError('TODO');
            if (f >= bitlen)
                return BigNumber.ZERO;
            if (b === undefined || b > bitlen - f)
                b = bitlen - f;
            var sliced = new BigNumber();
            var n = f >> 5;
            var m = (f + b + 31) >> 5;
            var l = (b + 31) >> 5;
            var t = f % 32;
            var k = b % 32;
            var slimbs = new Uint32Array(l);
            if (t) {
                for (var i = 0; i < m - n - 1; i++) {
                    slimbs[i] = (limbs[n + i] >>> t) | (limbs[n + i + 1] << (32 - t));
                }
                slimbs[i] = limbs[n + i] >>> t;
            }
            else {
                slimbs.set(limbs.subarray(n, m));
            }
            if (k) {
                slimbs[l - 1] &= -1 >>> (32 - k);
            }
            sliced.limbs = slimbs;
            sliced.bitLength = b;
            sliced.sign = this.sign;
            return sliced;
        };
        BigNumber.prototype.negate = function () {
            var negative = new BigNumber();
            negative.limbs = this.limbs;
            negative.bitLength = this.bitLength;
            negative.sign = -1 * this.sign;
            return negative;
        };
        BigNumber.prototype.compare = function (that) {
            var alimbs = this.limbs, alimbcnt = alimbs.length, blimbs = that.limbs, blimbcnt = blimbs.length, z = 0;
            if (this.sign < that.sign)
                return -1;
            if (this.sign > that.sign)
                return 1;
            _bigint_heap.set(alimbs, 0);
            _bigint_heap.set(blimbs, alimbcnt);
            z = _bigint_asm.cmp(0, alimbcnt << 2, alimbcnt << 2, blimbcnt << 2);
            return z * this.sign;
        };
        BigNumber.prototype.add = function (that) {
            if (!this.sign)
                return that;
            if (!that.sign)
                return this;
            var abitlen = this.bitLength, alimbs = this.limbs, alimbcnt = alimbs.length, asign = this.sign, bbitlen = that.bitLength, blimbs = that.limbs, blimbcnt = blimbs.length, bsign = that.sign, rbitlen, rlimbcnt, rsign, rof, result = new BigNumber();
            rbitlen = (abitlen > bbitlen ? abitlen : bbitlen) + (asign * bsign > 0 ? 1 : 0);
            rlimbcnt = (rbitlen + 31) >> 5;
            _bigint_asm.sreset();
            var pA = _bigint_asm.salloc(alimbcnt << 2), pB = _bigint_asm.salloc(blimbcnt << 2), pR = _bigint_asm.salloc(rlimbcnt << 2);
            _bigint_asm.z(pR - pA + (rlimbcnt << 2), 0, pA);
            _bigint_heap.set(alimbs, pA >> 2);
            _bigint_heap.set(blimbs, pB >> 2);
            if (asign * bsign > 0) {
                _bigint_asm.add(pA, alimbcnt << 2, pB, blimbcnt << 2, pR, rlimbcnt << 2);
                rsign = asign;
            }
            else if (asign > bsign) {
                rof = _bigint_asm.sub(pA, alimbcnt << 2, pB, blimbcnt << 2, pR, rlimbcnt << 2);
                rsign = rof ? bsign : asign;
            }
            else {
                rof = _bigint_asm.sub(pB, blimbcnt << 2, pA, alimbcnt << 2, pR, rlimbcnt << 2);
                rsign = rof ? asign : bsign;
            }
            if (rof)
                _bigint_asm.neg(pR, rlimbcnt << 2, pR, rlimbcnt << 2);
            if (_bigint_asm.tst(pR, rlimbcnt << 2) === 0)
                return BigNumber.ZERO;
            result.limbs = new Uint32Array(_bigint_heap.subarray(pR >> 2, (pR >> 2) + rlimbcnt));
            result.bitLength = rbitlen;
            result.sign = rsign;
            return result;
        };
        BigNumber.prototype.subtract = function (that) {
            return this.add(that.negate());
        };
        BigNumber.prototype.square = function () {
            if (!this.sign)
                return BigNumber.ZERO;
            var abitlen = this.bitLength, alimbs = this.limbs, alimbcnt = alimbs.length, rbitlen, rlimbcnt, result = new BigNumber();
            rbitlen = abitlen << 1;
            rlimbcnt = (rbitlen + 31) >> 5;
            _bigint_asm.sreset();
            var pA = _bigint_asm.salloc(alimbcnt << 2), pR = _bigint_asm.salloc(rlimbcnt << 2);
            _bigint_asm.z(pR - pA + (rlimbcnt << 2), 0, pA);
            _bigint_heap.set(alimbs, pA >> 2);
            _bigint_asm.sqr(pA, alimbcnt << 2, pR);
            result.limbs = new Uint32Array(_bigint_heap.subarray(pR >> 2, (pR >> 2) + rlimbcnt));
            result.bitLength = rbitlen;
            result.sign = 1;
            return result;
        };
        BigNumber.prototype.divide = function (that) {
            var abitlen = this.bitLength, alimbs = this.limbs, alimbcnt = alimbs.length, bbitlen = that.bitLength, blimbs = that.limbs, blimbcnt = blimbs.length, qlimbcnt, rlimbcnt, quotient = BigNumber.ZERO, remainder = BigNumber.ZERO;
            _bigint_asm.sreset();
            var pA = _bigint_asm.salloc(alimbcnt << 2), pB = _bigint_asm.salloc(blimbcnt << 2), pQ = _bigint_asm.salloc(alimbcnt << 2);
            _bigint_asm.z(pQ - pA + (alimbcnt << 2), 0, pA);
            _bigint_heap.set(alimbs, pA >> 2);
            _bigint_heap.set(blimbs, pB >> 2);
            _bigint_asm.div(pA, alimbcnt << 2, pB, blimbcnt << 2, pQ);
            qlimbcnt = _bigint_asm.tst(pQ, alimbcnt << 2) >> 2;
            if (qlimbcnt) {
                quotient = new BigNumber();
                quotient.limbs = new Uint32Array(_bigint_heap.subarray(pQ >> 2, (pQ >> 2) + qlimbcnt));
                quotient.bitLength = abitlen < qlimbcnt << 5 ? abitlen : qlimbcnt << 5;
                quotient.sign = this.sign * that.sign;
            }
            rlimbcnt = _bigint_asm.tst(pA, blimbcnt << 2) >> 2;
            if (rlimbcnt) {
                remainder = new BigNumber();
                remainder.limbs = new Uint32Array(_bigint_heap.subarray(pA >> 2, (pA >> 2) + rlimbcnt));
                remainder.bitLength = bbitlen < rlimbcnt << 5 ? bbitlen : rlimbcnt << 5;
                remainder.sign = this.sign;
            }
            return {
                quotient: quotient,
                remainder: remainder,
            };
        };
        BigNumber.prototype.multiply = function (that) {
            if (!this.sign || !that.sign)
                return BigNumber.ZERO;
            var abitlen = this.bitLength, alimbs = this.limbs, alimbcnt = alimbs.length, bbitlen = that.bitLength, blimbs = that.limbs, blimbcnt = blimbs.length, rbitlen, rlimbcnt, result = new BigNumber();
            rbitlen = abitlen + bbitlen;
            rlimbcnt = (rbitlen + 31) >> 5;
            _bigint_asm.sreset();
            var pA = _bigint_asm.salloc(alimbcnt << 2), pB = _bigint_asm.salloc(blimbcnt << 2), pR = _bigint_asm.salloc(rlimbcnt << 2);
            _bigint_asm.z(pR - pA + (rlimbcnt << 2), 0, pA);
            _bigint_heap.set(alimbs, pA >> 2);
            _bigint_heap.set(blimbs, pB >> 2);
            _bigint_asm.mul(pA, alimbcnt << 2, pB, blimbcnt << 2, pR, rlimbcnt << 2);
            result.limbs = new Uint32Array(_bigint_heap.subarray(pR >> 2, (pR >> 2) + rlimbcnt));
            result.sign = this.sign * that.sign;
            result.bitLength = rbitlen;
            return result;
        };
        BigNumber.prototype.isMillerRabinProbablePrime = function (rounds) {
            var t = BigNumber.fromConfig(this), s = 0;
            t.limbs[0] -= 1;
            while (t.limbs[s >> 5] === 0)
                s += 32;
            while (((t.limbs[s >> 5] >> (s & 31)) & 1) === 0)
                s++;
            t = t.slice(s);
            var m = new Modulus(this), m1 = this.subtract(BigNumber.ONE), a = BigNumber.fromConfig(this), l = this.limbs.length - 1;
            while (a.limbs[l] === 0)
                l--;
            while (--rounds >= 0) {
                getRandomValues(a.limbs);
                if (a.limbs[0] < 2)
                    a.limbs[0] += 2;
                while (a.compare(m1) >= 0)
                    a.limbs[l] >>>= 1;
                var x = m.power(a, t);
                if (x.compare(BigNumber.ONE) === 0)
                    continue;
                if (x.compare(m1) === 0)
                    continue;
                var c = s;
                while (--c > 0) {
                    x = x.square().divide(m).remainder;
                    if (x.compare(BigNumber.ONE) === 0)
                        return false;
                    if (x.compare(m1) === 0)
                        break;
                }
                if (c === 0)
                    return false;
            }
            return true;
        };
        BigNumber.prototype.isProbablePrime = function (paranoia) {
            if (paranoia === void 0) { paranoia = 80; }
            var limbs = this.limbs;
            var i = 0;
            // Oddity test
            // (50% false positive probability)
            if ((limbs[0] & 1) === 0)
                return false;
            if (paranoia <= 1)
                return true;
            // Magic divisors (3, 5, 17) test
            // (~25% false positive probability)
            var s3 = 0, s5 = 0, s17 = 0;
            for (i = 0; i < limbs.length; i++) {
                var l3 = limbs[i];
                while (l3) {
                    s3 += l3 & 3;
                    l3 >>>= 2;
                }
                var l5 = limbs[i];
                while (l5) {
                    s5 += l5 & 3;
                    l5 >>>= 2;
                    s5 -= l5 & 3;
                    l5 >>>= 2;
                }
                var l17 = limbs[i];
                while (l17) {
                    s17 += l17 & 15;
                    l17 >>>= 4;
                    s17 -= l17 & 15;
                    l17 >>>= 4;
                }
            }
            if (!(s3 % 3) || !(s5 % 5) || !(s17 % 17))
                return false;
            if (paranoia <= 2)
                return true;
            // Miller-Rabin test
            // (≤ 4^(-k) false positive probability)
            return this.isMillerRabinProbablePrime(paranoia >>> 1);
        };
        BigNumber.extGCD = BigNumber_extGCD;
        BigNumber.ZERO = BigNumber.fromNumber(0);
        BigNumber.ONE = BigNumber.fromNumber(1);
        return BigNumber;
    }());
    var Modulus = /** @class */ (function (_super) {
        __extends$1(Modulus, _super);
        function Modulus(number) {
            var _this = _super.call(this) || this;
            _this.limbs = number.limbs;
            _this.bitLength = number.bitLength;
            _this.sign = number.sign;
            if (_this.valueOf() < 1)
                throw new RangeError();
            if (_this.bitLength <= 32)
                return _this;
            var comodulus;
            if (_this.limbs[0] & 1) {
                var bitlen = ((_this.bitLength + 31) & -32) + 1;
                var limbs = new Uint32Array((bitlen + 31) >> 5);
                limbs[limbs.length - 1] = 1;
                comodulus = new BigNumber();
                comodulus.sign = 1;
                comodulus.bitLength = bitlen;
                comodulus.limbs = limbs;
                var k = Number_extGCD(0x100000000, _this.limbs[0]).y;
                _this.coefficient = k < 0 ? -k : 0x100000000 - k;
            }
            else {
                return _this;
            }
            _this.comodulus = comodulus;
            _this.comodulusRemainder = comodulus.divide(_this).remainder;
            _this.comodulusRemainderSquare = comodulus.square().divide(_this).remainder;
            return _this;
        }
        /**
         * Modular reduction
         */
        Modulus.prototype.reduce = function (a) {
            if (a.bitLength <= 32 && this.bitLength <= 32)
                return BigNumber.fromNumber(a.valueOf() % this.valueOf());
            if (a.compare(this) < 0)
                return a;
            return a.divide(this).remainder;
        };
        /**
         * Modular inverse
         */
        Modulus.prototype.inverse = function (a) {
            a = this.reduce(a);
            var r = BigNumber_extGCD(this, a);
            if (r.gcd.valueOf() !== 1)
                throw new Error('GCD is not 1');
            if (r.y.sign < 0)
                return r.y.add(this).clamp(this.bitLength);
            return r.y;
        };
        /**
         * Modular exponentiation
         */
        Modulus.prototype.power = function (g, e) {
            // count exponent set bits
            var c = 0;
            for (var i = 0; i < e.limbs.length; i++) {
                var t = e.limbs[i];
                while (t) {
                    if (t & 1)
                        c++;
                    t >>>= 1;
                }
            }
            // window size parameter
            var k = 8;
            if (e.bitLength <= 4536)
                k = 7;
            if (e.bitLength <= 1736)
                k = 6;
            if (e.bitLength <= 630)
                k = 5;
            if (e.bitLength <= 210)
                k = 4;
            if (e.bitLength <= 60)
                k = 3;
            if (e.bitLength <= 12)
                k = 2;
            if (c <= 1 << (k - 1))
                k = 1;
            // montgomerize base
            g = Modulus._Montgomery_reduce(this.reduce(g).multiply(this.comodulusRemainderSquare), this);
            // precompute odd powers
            var g2 = Modulus._Montgomery_reduce(g.square(), this), gn = new Array(1 << (k - 1));
            gn[0] = g;
            gn[1] = Modulus._Montgomery_reduce(g.multiply(g2), this);
            for (var i = 2; i < 1 << (k - 1); i++) {
                gn[i] = Modulus._Montgomery_reduce(gn[i - 1].multiply(g2), this);
            }
            // perform exponentiation
            var u = this.comodulusRemainder;
            var r = u;
            for (var i = e.limbs.length - 1; i >= 0; i--) {
                var t = e.limbs[i];
                for (var j = 32; j > 0;) {
                    if (t & 0x80000000) {
                        var n = t >>> (32 - k), l = k;
                        while ((n & 1) === 0) {
                            n >>>= 1;
                            l--;
                        }
                        var m = gn[n >>> 1];
                        while (n) {
                            n >>>= 1;
                            if (r !== u)
                                r = Modulus._Montgomery_reduce(r.square(), this);
                        }
                        r = r !== u ? Modulus._Montgomery_reduce(r.multiply(m), this) : m;
                        (t <<= l), (j -= l);
                    }
                    else {
                        if (r !== u)
                            r = Modulus._Montgomery_reduce(r.square(), this);
                        (t <<= 1), j--;
                    }
                }
            }
            // de-montgomerize result
            return Modulus._Montgomery_reduce(r, this);
        };
        Modulus._Montgomery_reduce = function (a, n) {
            var alimbs = a.limbs;
            var alimbcnt = alimbs.length;
            var nlimbs = n.limbs;
            var nlimbcnt = nlimbs.length;
            var y = n.coefficient;
            _bigint_asm.sreset();
            var pA = _bigint_asm.salloc(alimbcnt << 2), pN = _bigint_asm.salloc(nlimbcnt << 2), pR = _bigint_asm.salloc(nlimbcnt << 2);
            _bigint_asm.z(pR - pA + (nlimbcnt << 2), 0, pA);
            _bigint_heap.set(alimbs, pA >> 2);
            _bigint_heap.set(nlimbs, pN >> 2);
            _bigint_asm.mredc(pA, alimbcnt << 2, pN, nlimbcnt << 2, y, pR);
            var result = new BigNumber();
            result.limbs = new Uint32Array(_bigint_heap.subarray(pR >> 2, (pR >> 2) + nlimbcnt));
            result.bitLength = n.bitLength;
            result.sign = 1;
            return result;
        };
        return Modulus;
    }(BigNumber));

    var sha1_asm = function ( stdlib, foreign, buffer ) {
        "use asm";

        // SHA256 state
        var H0 = 0, H1 = 0, H2 = 0, H3 = 0, H4 = 0,
            TOTAL0 = 0, TOTAL1 = 0;

        // HMAC state
        var I0 = 0, I1 = 0, I2 = 0, I3 = 0, I4 = 0,
            O0 = 0, O1 = 0, O2 = 0, O3 = 0, O4 = 0;

        // I/O buffer
        var HEAP = new stdlib.Uint8Array(buffer);

        function _core ( w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15 ) {
            w0 = w0|0;
            w1 = w1|0;
            w2 = w2|0;
            w3 = w3|0;
            w4 = w4|0;
            w5 = w5|0;
            w6 = w6|0;
            w7 = w7|0;
            w8 = w8|0;
            w9 = w9|0;
            w10 = w10|0;
            w11 = w11|0;
            w12 = w12|0;
            w13 = w13|0;
            w14 = w14|0;
            w15 = w15|0;

            var a = 0, b = 0, c = 0, d = 0, e = 0, n = 0, t = 0,
                w16 = 0, w17 = 0, w18 = 0, w19 = 0,
                w20 = 0, w21 = 0, w22 = 0, w23 = 0, w24 = 0, w25 = 0, w26 = 0, w27 = 0, w28 = 0, w29 = 0,
                w30 = 0, w31 = 0, w32 = 0, w33 = 0, w34 = 0, w35 = 0, w36 = 0, w37 = 0, w38 = 0, w39 = 0,
                w40 = 0, w41 = 0, w42 = 0, w43 = 0, w44 = 0, w45 = 0, w46 = 0, w47 = 0, w48 = 0, w49 = 0,
                w50 = 0, w51 = 0, w52 = 0, w53 = 0, w54 = 0, w55 = 0, w56 = 0, w57 = 0, w58 = 0, w59 = 0,
                w60 = 0, w61 = 0, w62 = 0, w63 = 0, w64 = 0, w65 = 0, w66 = 0, w67 = 0, w68 = 0, w69 = 0,
                w70 = 0, w71 = 0, w72 = 0, w73 = 0, w74 = 0, w75 = 0, w76 = 0, w77 = 0, w78 = 0, w79 = 0;

            a = H0;
            b = H1;
            c = H2;
            d = H3;
            e = H4;

            // 0
            t = ( w0 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 1
            t = ( w1 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 2
            t = ( w2 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 3
            t = ( w3 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 4
            t = ( w4 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 5
            t = ( w5 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 6
            t = ( w6 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 7
            t = ( w7 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 8
            t = ( w8 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 9
            t = ( w9 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 10
            t = ( w10 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 11
            t = ( w11 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 12
            t = ( w12 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 13
            t = ( w13 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 14
            t = ( w14 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 15
            t = ( w15 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 16
            n = w13 ^ w8 ^ w2 ^ w0;
            w16 = (n << 1) | (n >>> 31);
            t = (w16 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 17
            n = w14 ^ w9 ^ w3 ^ w1;
            w17 = (n << 1) | (n >>> 31);
            t = (w17 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 18
            n = w15 ^ w10 ^ w4 ^ w2;
            w18 = (n << 1) | (n >>> 31);
            t = (w18 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 19
            n = w16 ^ w11 ^ w5 ^ w3;
            w19 = (n << 1) | (n >>> 31);
            t = (w19 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (~b & d)) + 0x5a827999 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 20
            n = w17 ^ w12 ^ w6 ^ w4;
            w20 = (n << 1) | (n >>> 31);
            t = (w20 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 21
            n = w18 ^ w13 ^ w7 ^ w5;
            w21 = (n << 1) | (n >>> 31);
            t = (w21 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 22
            n = w19 ^ w14 ^ w8 ^ w6;
            w22 = (n << 1) | (n >>> 31);
            t = (w22 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 23
            n = w20 ^ w15 ^ w9 ^ w7;
            w23 = (n << 1) | (n >>> 31);
            t = (w23 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 24
            n = w21 ^ w16 ^ w10 ^ w8;
            w24 = (n << 1) | (n >>> 31);
            t = (w24 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 25
            n = w22 ^ w17 ^ w11 ^ w9;
            w25 = (n << 1) | (n >>> 31);
            t = (w25 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 26
            n = w23 ^ w18 ^ w12 ^ w10;
            w26 = (n << 1) | (n >>> 31);
            t = (w26 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 27
            n = w24 ^ w19 ^ w13 ^ w11;
            w27 = (n << 1) | (n >>> 31);
            t = (w27 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 28
            n = w25 ^ w20 ^ w14 ^ w12;
            w28 = (n << 1) | (n >>> 31);
            t = (w28 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 29
            n = w26 ^ w21 ^ w15 ^ w13;
            w29 = (n << 1) | (n >>> 31);
            t = (w29 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 30
            n = w27 ^ w22 ^ w16 ^ w14;
            w30 = (n << 1) | (n >>> 31);
            t = (w30 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 31
            n = w28 ^ w23 ^ w17 ^ w15;
            w31 = (n << 1) | (n >>> 31);
            t = (w31 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 32
            n = w29 ^ w24 ^ w18 ^ w16;
            w32 = (n << 1) | (n >>> 31);
            t = (w32 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 33
            n = w30 ^ w25 ^ w19 ^ w17;
            w33 = (n << 1) | (n >>> 31);
            t = (w33 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 34
            n = w31 ^ w26 ^ w20 ^ w18;
            w34 = (n << 1) | (n >>> 31);
            t = (w34 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 35
            n = w32 ^ w27 ^ w21 ^ w19;
            w35 = (n << 1) | (n >>> 31);
            t = (w35 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 36
            n = w33 ^ w28 ^ w22 ^ w20;
            w36 = (n << 1) | (n >>> 31);
            t = (w36 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 37
            n = w34 ^ w29 ^ w23 ^ w21;
            w37 = (n << 1) | (n >>> 31);
            t = (w37 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 38
            n = w35 ^ w30 ^ w24 ^ w22;
            w38 = (n << 1) | (n >>> 31);
            t = (w38 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 39
            n = w36 ^ w31 ^ w25 ^ w23;
            w39 = (n << 1) | (n >>> 31);
            t = (w39 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) + 0x6ed9eba1 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 40
            n = w37 ^ w32 ^ w26 ^ w24;
            w40 = (n << 1) | (n >>> 31);
            t = (w40 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 41
            n = w38 ^ w33 ^ w27 ^ w25;
            w41 = (n << 1) | (n >>> 31);
            t = (w41 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 42
            n = w39 ^ w34 ^ w28 ^ w26;
            w42 = (n << 1) | (n >>> 31);
            t = (w42 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 43
            n = w40 ^ w35 ^ w29 ^ w27;
            w43 = (n << 1) | (n >>> 31);
            t = (w43 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 44
            n = w41 ^ w36 ^ w30 ^ w28;
            w44 = (n << 1) | (n >>> 31);
            t = (w44 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 45
            n = w42 ^ w37 ^ w31 ^ w29;
            w45 = (n << 1) | (n >>> 31);
            t = (w45 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 46
            n = w43 ^ w38 ^ w32 ^ w30;
            w46 = (n << 1) | (n >>> 31);
            t = (w46 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 47
            n = w44 ^ w39 ^ w33 ^ w31;
            w47 = (n << 1) | (n >>> 31);
            t = (w47 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 48
            n = w45 ^ w40 ^ w34 ^ w32;
            w48 = (n << 1) | (n >>> 31);
            t = (w48 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 49
            n = w46 ^ w41 ^ w35 ^ w33;
            w49 = (n << 1) | (n >>> 31);
            t = (w49 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 50
            n = w47 ^ w42 ^ w36 ^ w34;
            w50 = (n << 1) | (n >>> 31);
            t = (w50 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 51
            n = w48 ^ w43 ^ w37 ^ w35;
            w51 = (n << 1) | (n >>> 31);
            t = (w51 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 52
            n = w49 ^ w44 ^ w38 ^ w36;
            w52 = (n << 1) | (n >>> 31);
            t = (w52 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 53
            n = w50 ^ w45 ^ w39 ^ w37;
            w53 = (n << 1) | (n >>> 31);
            t = (w53 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 54
            n = w51 ^ w46 ^ w40 ^ w38;
            w54 = (n << 1) | (n >>> 31);
            t = (w54 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 55
            n = w52 ^ w47 ^ w41 ^ w39;
            w55 = (n << 1) | (n >>> 31);
            t = (w55 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 56
            n = w53 ^ w48 ^ w42 ^ w40;
            w56 = (n << 1) | (n >>> 31);
            t = (w56 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 57
            n = w54 ^ w49 ^ w43 ^ w41;
            w57 = (n << 1) | (n >>> 31);
            t = (w57 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 58
            n = w55 ^ w50 ^ w44 ^ w42;
            w58 = (n << 1) | (n >>> 31);
            t = (w58 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 59
            n = w56 ^ w51 ^ w45 ^ w43;
            w59 = (n << 1) | (n >>> 31);
            t = (w59 + ((a << 5) | (a >>> 27)) + e + ((b & c) | (b & d) | (c & d)) - 0x70e44324 )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 60
            n = w57 ^ w52 ^ w46 ^ w44;
            w60 = (n << 1) | (n >>> 31);
            t = (w60 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 61
            n = w58 ^ w53 ^ w47 ^ w45;
            w61 = (n << 1) | (n >>> 31);
            t = (w61 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 62
            n = w59 ^ w54 ^ w48 ^ w46;
            w62 = (n << 1) | (n >>> 31);
            t = (w62 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 63
            n = w60 ^ w55 ^ w49 ^ w47;
            w63 = (n << 1) | (n >>> 31);
            t = (w63 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 64
            n = w61 ^ w56 ^ w50 ^ w48;
            w64 = (n << 1) | (n >>> 31);
            t = (w64 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 65
            n = w62 ^ w57 ^ w51 ^ w49;
            w65 = (n << 1) | (n >>> 31);
            t = (w65 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 66
            n = w63 ^ w58 ^ w52 ^ w50;
            w66 = (n << 1) | (n >>> 31);
            t = (w66 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 67
            n = w64 ^ w59 ^ w53 ^ w51;
            w67 = (n << 1) | (n >>> 31);
            t = (w67 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 68
            n = w65 ^ w60 ^ w54 ^ w52;
            w68 = (n << 1) | (n >>> 31);
            t = (w68 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 69
            n = w66 ^ w61 ^ w55 ^ w53;
            w69 = (n << 1) | (n >>> 31);
            t = (w69 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 70
            n = w67 ^ w62 ^ w56 ^ w54;
            w70 = (n << 1) | (n >>> 31);
            t = (w70 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 71
            n = w68 ^ w63 ^ w57 ^ w55;
            w71 = (n << 1) | (n >>> 31);
            t = (w71 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 72
            n = w69 ^ w64 ^ w58 ^ w56;
            w72 = (n << 1) | (n >>> 31);
            t = (w72 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 73
            n = w70 ^ w65 ^ w59 ^ w57;
            w73 = (n << 1) | (n >>> 31);
            t = (w73 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 74
            n = w71 ^ w66 ^ w60 ^ w58;
            w74 = (n << 1) | (n >>> 31);
            t = (w74 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 75
            n = w72 ^ w67 ^ w61 ^ w59;
            w75 = (n << 1) | (n >>> 31);
            t = (w75 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 76
            n = w73 ^ w68 ^ w62 ^ w60;
            w76 = (n << 1) | (n >>> 31);
            t = (w76 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 77
            n = w74 ^ w69 ^ w63 ^ w61;
            w77 = (n << 1) | (n >>> 31);
            t = (w77 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 78
            n = w75 ^ w70 ^ w64 ^ w62;
            w78 = (n << 1) | (n >>> 31);
            t = (w78 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            // 79
            n = w76 ^ w71 ^ w65 ^ w63;
            w79 = (n << 1) | (n >>> 31);
            t = (w79 + ((a << 5) | (a >>> 27)) + e + (b ^ c ^ d) - 0x359d3e2a )|0;
            e = d; d = c; c = (b << 30) | (b >>> 2); b = a; a = t;

            H0 = ( H0 + a )|0;
            H1 = ( H1 + b )|0;
            H2 = ( H2 + c )|0;
            H3 = ( H3 + d )|0;
            H4 = ( H4 + e )|0;

        }

        function _core_heap ( offset ) {
            offset = offset|0;

            _core(
                HEAP[offset|0]<<24 | HEAP[offset|1]<<16 | HEAP[offset|2]<<8 | HEAP[offset|3],
                HEAP[offset|4]<<24 | HEAP[offset|5]<<16 | HEAP[offset|6]<<8 | HEAP[offset|7],
                HEAP[offset|8]<<24 | HEAP[offset|9]<<16 | HEAP[offset|10]<<8 | HEAP[offset|11],
                HEAP[offset|12]<<24 | HEAP[offset|13]<<16 | HEAP[offset|14]<<8 | HEAP[offset|15],
                HEAP[offset|16]<<24 | HEAP[offset|17]<<16 | HEAP[offset|18]<<8 | HEAP[offset|19],
                HEAP[offset|20]<<24 | HEAP[offset|21]<<16 | HEAP[offset|22]<<8 | HEAP[offset|23],
                HEAP[offset|24]<<24 | HEAP[offset|25]<<16 | HEAP[offset|26]<<8 | HEAP[offset|27],
                HEAP[offset|28]<<24 | HEAP[offset|29]<<16 | HEAP[offset|30]<<8 | HEAP[offset|31],
                HEAP[offset|32]<<24 | HEAP[offset|33]<<16 | HEAP[offset|34]<<8 | HEAP[offset|35],
                HEAP[offset|36]<<24 | HEAP[offset|37]<<16 | HEAP[offset|38]<<8 | HEAP[offset|39],
                HEAP[offset|40]<<24 | HEAP[offset|41]<<16 | HEAP[offset|42]<<8 | HEAP[offset|43],
                HEAP[offset|44]<<24 | HEAP[offset|45]<<16 | HEAP[offset|46]<<8 | HEAP[offset|47],
                HEAP[offset|48]<<24 | HEAP[offset|49]<<16 | HEAP[offset|50]<<8 | HEAP[offset|51],
                HEAP[offset|52]<<24 | HEAP[offset|53]<<16 | HEAP[offset|54]<<8 | HEAP[offset|55],
                HEAP[offset|56]<<24 | HEAP[offset|57]<<16 | HEAP[offset|58]<<8 | HEAP[offset|59],
                HEAP[offset|60]<<24 | HEAP[offset|61]<<16 | HEAP[offset|62]<<8 | HEAP[offset|63]
            );
        }

        // offset — multiple of 32
        function _state_to_heap ( output ) {
            output = output|0;

            HEAP[output|0] = H0>>>24;
            HEAP[output|1] = H0>>>16&255;
            HEAP[output|2] = H0>>>8&255;
            HEAP[output|3] = H0&255;
            HEAP[output|4] = H1>>>24;
            HEAP[output|5] = H1>>>16&255;
            HEAP[output|6] = H1>>>8&255;
            HEAP[output|7] = H1&255;
            HEAP[output|8] = H2>>>24;
            HEAP[output|9] = H2>>>16&255;
            HEAP[output|10] = H2>>>8&255;
            HEAP[output|11] = H2&255;
            HEAP[output|12] = H3>>>24;
            HEAP[output|13] = H3>>>16&255;
            HEAP[output|14] = H3>>>8&255;
            HEAP[output|15] = H3&255;
            HEAP[output|16] = H4>>>24;
            HEAP[output|17] = H4>>>16&255;
            HEAP[output|18] = H4>>>8&255;
            HEAP[output|19] = H4&255;
        }

        function reset () {
            H0 = 0x67452301;
            H1 = 0xefcdab89;
            H2 = 0x98badcfe;
            H3 = 0x10325476;
            H4 = 0xc3d2e1f0;
            TOTAL0 = TOTAL1 = 0;
        }

        function init ( h0, h1, h2, h3, h4, total0, total1 ) {
            h0 = h0|0;
            h1 = h1|0;
            h2 = h2|0;
            h3 = h3|0;
            h4 = h4|0;
            total0 = total0|0;
            total1 = total1|0;

            H0 = h0;
            H1 = h1;
            H2 = h2;
            H3 = h3;
            H4 = h4;
            TOTAL0 = total0;
            TOTAL1 = total1;
        }

        // offset — multiple of 64
        function process ( offset, length ) {
            offset = offset|0;
            length = length|0;

            var hashed = 0;

            if ( offset & 63 )
                return -1;

            while ( (length|0) >= 64 ) {
                _core_heap(offset);

                offset = ( offset + 64 )|0;
                length = ( length - 64 )|0;

                hashed = ( hashed + 64 )|0;
            }

            TOTAL0 = ( TOTAL0 + hashed )|0;
            if ( TOTAL0>>>0 < hashed>>>0 ) TOTAL1 = ( TOTAL1 + 1 )|0;

            return hashed|0;
        }

        // offset — multiple of 64
        // output — multiple of 32
        function finish ( offset, length, output ) {
            offset = offset|0;
            length = length|0;
            output = output|0;

            var hashed = 0,
                i = 0;

            if ( offset & 63 )
                return -1;

            if ( ~output )
                if ( output & 31 )
                    return -1;

            if ( (length|0) >= 64 ) {
                hashed = process( offset, length )|0;
                if ( (hashed|0) == -1 )
                    return -1;

                offset = ( offset + hashed )|0;
                length = ( length - hashed )|0;
            }

            hashed = ( hashed + length )|0;
            TOTAL0 = ( TOTAL0 + length )|0;
            if ( TOTAL0>>>0 < length>>>0 ) TOTAL1 = (TOTAL1 + 1)|0;

            HEAP[offset|length] = 0x80;

            if ( (length|0) >= 56 ) {
                for ( i = (length+1)|0; (i|0) < 64; i = (i+1)|0 )
                    HEAP[offset|i] = 0x00;
                _core_heap(offset);

                length = 0;

                HEAP[offset|0] = 0;
            }

            for ( i = (length+1)|0; (i|0) < 59; i = (i+1)|0 )
                HEAP[offset|i] = 0;

            HEAP[offset|56] = TOTAL1>>>21&255;
            HEAP[offset|57] = TOTAL1>>>13&255;
            HEAP[offset|58] = TOTAL1>>>5&255;
            HEAP[offset|59] = TOTAL1<<3&255 | TOTAL0>>>29;
            HEAP[offset|60] = TOTAL0>>>21&255;
            HEAP[offset|61] = TOTAL0>>>13&255;
            HEAP[offset|62] = TOTAL0>>>5&255;
            HEAP[offset|63] = TOTAL0<<3&255;
            _core_heap(offset);

            if ( ~output )
                _state_to_heap(output);

            return hashed|0;
        }

        function hmac_reset () {
            H0 = I0;
            H1 = I1;
            H2 = I2;
            H3 = I3;
            H4 = I4;
            TOTAL0 = 64;
            TOTAL1 = 0;
        }

        function _hmac_opad () {
            H0 = O0;
            H1 = O1;
            H2 = O2;
            H3 = O3;
            H4 = O4;
            TOTAL0 = 64;
            TOTAL1 = 0;
        }

        function hmac_init ( p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ) {
            p0 = p0|0;
            p1 = p1|0;
            p2 = p2|0;
            p3 = p3|0;
            p4 = p4|0;
            p5 = p5|0;
            p6 = p6|0;
            p7 = p7|0;
            p8 = p8|0;
            p9 = p9|0;
            p10 = p10|0;
            p11 = p11|0;
            p12 = p12|0;
            p13 = p13|0;
            p14 = p14|0;
            p15 = p15|0;

            // opad
            reset();
            _core(
                p0 ^ 0x5c5c5c5c,
                p1 ^ 0x5c5c5c5c,
                p2 ^ 0x5c5c5c5c,
                p3 ^ 0x5c5c5c5c,
                p4 ^ 0x5c5c5c5c,
                p5 ^ 0x5c5c5c5c,
                p6 ^ 0x5c5c5c5c,
                p7 ^ 0x5c5c5c5c,
                p8 ^ 0x5c5c5c5c,
                p9 ^ 0x5c5c5c5c,
                p10 ^ 0x5c5c5c5c,
                p11 ^ 0x5c5c5c5c,
                p12 ^ 0x5c5c5c5c,
                p13 ^ 0x5c5c5c5c,
                p14 ^ 0x5c5c5c5c,
                p15 ^ 0x5c5c5c5c
            );
            O0 = H0;
            O1 = H1;
            O2 = H2;
            O3 = H3;
            O4 = H4;

            // ipad
            reset();
            _core(
                p0 ^ 0x36363636,
                p1 ^ 0x36363636,
                p2 ^ 0x36363636,
                p3 ^ 0x36363636,
                p4 ^ 0x36363636,
                p5 ^ 0x36363636,
                p6 ^ 0x36363636,
                p7 ^ 0x36363636,
                p8 ^ 0x36363636,
                p9 ^ 0x36363636,
                p10 ^ 0x36363636,
                p11 ^ 0x36363636,
                p12 ^ 0x36363636,
                p13 ^ 0x36363636,
                p14 ^ 0x36363636,
                p15 ^ 0x36363636
            );
            I0 = H0;
            I1 = H1;
            I2 = H2;
            I3 = H3;
            I4 = H4;

            TOTAL0 = 64;
            TOTAL1 = 0;
        }

        // offset — multiple of 64
        // output — multiple of 32
        function hmac_finish ( offset, length, output ) {
            offset = offset|0;
            length = length|0;
            output = output|0;

            var t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, hashed = 0;

            if ( offset & 63 )
                return -1;

            if ( ~output )
                if ( output & 31 )
                    return -1;

            hashed = finish( offset, length, -1 )|0;
            t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4;

            _hmac_opad();
            _core( t0, t1, t2, t3, t4, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 672 );

            if ( ~output )
                _state_to_heap(output);

            return hashed|0;
        }

        // salt is assumed to be already processed
        // offset — multiple of 64
        // output — multiple of 32
        function pbkdf2_generate_block ( offset, length, block, count, output ) {
            offset = offset|0;
            length = length|0;
            block = block|0;
            count = count|0;
            output = output|0;

            var h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0,
                t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0;

            if ( offset & 63 )
                return -1;

            if ( ~output )
                if ( output & 31 )
                    return -1;

            // pad block number into heap
            // FIXME probable OOB write
            HEAP[(offset+length)|0]   = block>>>24;
            HEAP[(offset+length+1)|0] = block>>>16&255;
            HEAP[(offset+length+2)|0] = block>>>8&255;
            HEAP[(offset+length+3)|0] = block&255;

            // finish first iteration
            hmac_finish( offset, (length+4)|0, -1 )|0;
            h0 = t0 = H0, h1 = t1 = H1, h2 = t2 = H2, h3 = t3 = H3, h4 = t4 = H4;
            count = (count-1)|0;

            // perform the rest iterations
            while ( (count|0) > 0 ) {
                hmac_reset();
                _core( t0, t1, t2, t3, t4, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 672 );
                t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4;

                _hmac_opad();
                _core( t0, t1, t2, t3, t4, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 672 );
                t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4;

                h0 = h0 ^ H0;
                h1 = h1 ^ H1;
                h2 = h2 ^ H2;
                h3 = h3 ^ H3;
                h4 = h4 ^ H4;

                count = (count-1)|0;
            }

            H0 = h0;
            H1 = h1;
            H2 = h2;
            H3 = h3;
            H4 = h4;

            if ( ~output )
                _state_to_heap(output);

            return 0;
        }

        return {
          // SHA1
          reset: reset,
          init: init,
          process: process,
          finish: finish,

          // HMAC-SHA1
          hmac_reset: hmac_reset,
          hmac_init: hmac_init,
          hmac_finish: hmac_finish,

          // PBKDF2-HMAC-SHA1
          pbkdf2_generate_block: pbkdf2_generate_block
        }
    };

    var Hash = /** @class */ (function () {
        function Hash() {
            this.pos = 0;
            this.len = 0;
        }
        Hash.prototype.reset = function () {
            this.result = null;
            this.pos = 0;
            this.len = 0;
            this.asm.reset();
            return this;
        };
        Hash.prototype.process = function (data) {
            if (this.result !== null)
                throw new IllegalStateError('state must be reset before processing new data');
            var asm = this.asm;
            var heap = this.heap;
            var hpos = this.pos;
            var hlen = this.len;
            var dpos = 0;
            var dlen = data.length;
            var wlen = 0;
            while (dlen > 0) {
                wlen = _heap_write(heap, hpos + hlen, data, dpos, dlen);
                hlen += wlen;
                dpos += wlen;
                dlen -= wlen;
                wlen = asm.process(hpos, hlen);
                hpos += wlen;
                hlen -= wlen;
                if (!hlen)
                    hpos = 0;
            }
            this.pos = hpos;
            this.len = hlen;
            return this;
        };
        Hash.prototype.finish = function () {
            if (this.result !== null)
                throw new IllegalStateError('state must be reset before processing new data');
            this.asm.finish(this.pos, this.len, 0);
            this.result = new Uint8Array(this.HASH_SIZE);
            this.result.set(this.heap.subarray(0, this.HASH_SIZE));
            this.pos = 0;
            this.len = 0;
            return this;
        };
        return Hash;
    }());

    var __extends$2 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var _sha1_block_size = 64;
    var _sha1_hash_size = 20;
    var Sha1 = /** @class */ (function (_super) {
        __extends$2(Sha1, _super);
        function Sha1() {
            var _this = _super.call(this) || this;
            _this.NAME = 'sha1';
            _this.BLOCK_SIZE = _sha1_block_size;
            _this.HASH_SIZE = _sha1_hash_size;
            _this.heap = _heap_init();
            _this.asm = sha1_asm({ Uint8Array: Uint8Array }, null, _this.heap.buffer);
            _this.reset();
            return _this;
        }
        Sha1.NAME = 'sha1';
        return Sha1;
    }(Hash));

    var sha256_asm = function ( stdlib, foreign, buffer ) {
        "use asm";

        // SHA256 state
        var H0 = 0, H1 = 0, H2 = 0, H3 = 0, H4 = 0, H5 = 0, H6 = 0, H7 = 0,
            TOTAL0 = 0, TOTAL1 = 0;

        // HMAC state
        var I0 = 0, I1 = 0, I2 = 0, I3 = 0, I4 = 0, I5 = 0, I6 = 0, I7 = 0,
            O0 = 0, O1 = 0, O2 = 0, O3 = 0, O4 = 0, O5 = 0, O6 = 0, O7 = 0;

        // I/O buffer
        var HEAP = new stdlib.Uint8Array(buffer);

        function _core ( w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15 ) {
            w0 = w0|0;
            w1 = w1|0;
            w2 = w2|0;
            w3 = w3|0;
            w4 = w4|0;
            w5 = w5|0;
            w6 = w6|0;
            w7 = w7|0;
            w8 = w8|0;
            w9 = w9|0;
            w10 = w10|0;
            w11 = w11|0;
            w12 = w12|0;
            w13 = w13|0;
            w14 = w14|0;
            w15 = w15|0;

            var a = 0, b = 0, c = 0, d = 0, e = 0, f = 0, g = 0, h = 0;

            a = H0;
            b = H1;
            c = H2;
            d = H3;
            e = H4;
            f = H5;
            g = H6;
            h = H7;
            
            // 0
            h = ( w0 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0x428a2f98 )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 1
            g = ( w1 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0x71374491 )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 2
            f = ( w2 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0xb5c0fbcf )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 3
            e = ( w3 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0xe9b5dba5 )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 4
            d = ( w4 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0x3956c25b )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 5
            c = ( w5 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0x59f111f1 )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 6
            b = ( w6 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0x923f82a4 )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 7
            a = ( w7 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0xab1c5ed5 )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            // 8
            h = ( w8 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0xd807aa98 )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 9
            g = ( w9 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0x12835b01 )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 10
            f = ( w10 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0x243185be )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 11
            e = ( w11 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0x550c7dc3 )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 12
            d = ( w12 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0x72be5d74 )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 13
            c = ( w13 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0x80deb1fe )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 14
            b = ( w14 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0x9bdc06a7 )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 15
            a = ( w15 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0xc19bf174 )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            // 16
            w0 = ( ( w1>>>7  ^ w1>>>18 ^ w1>>>3  ^ w1<<25 ^ w1<<14 ) + ( w14>>>17 ^ w14>>>19 ^ w14>>>10 ^ w14<<15 ^ w14<<13 ) + w0 + w9 )|0;
            h = ( w0 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0xe49b69c1 )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 17
            w1 = ( ( w2>>>7  ^ w2>>>18 ^ w2>>>3  ^ w2<<25 ^ w2<<14 ) + ( w15>>>17 ^ w15>>>19 ^ w15>>>10 ^ w15<<15 ^ w15<<13 ) + w1 + w10 )|0;
            g = ( w1 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0xefbe4786 )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 18
            w2 = ( ( w3>>>7  ^ w3>>>18 ^ w3>>>3  ^ w3<<25 ^ w3<<14 ) + ( w0>>>17 ^ w0>>>19 ^ w0>>>10 ^ w0<<15 ^ w0<<13 ) + w2 + w11 )|0;
            f = ( w2 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0x0fc19dc6 )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 19
            w3 = ( ( w4>>>7  ^ w4>>>18 ^ w4>>>3  ^ w4<<25 ^ w4<<14 ) + ( w1>>>17 ^ w1>>>19 ^ w1>>>10 ^ w1<<15 ^ w1<<13 ) + w3 + w12 )|0;
            e = ( w3 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0x240ca1cc )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 20
            w4 = ( ( w5>>>7  ^ w5>>>18 ^ w5>>>3  ^ w5<<25 ^ w5<<14 ) + ( w2>>>17 ^ w2>>>19 ^ w2>>>10 ^ w2<<15 ^ w2<<13 ) + w4 + w13 )|0;
            d = ( w4 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0x2de92c6f )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 21
            w5 = ( ( w6>>>7  ^ w6>>>18 ^ w6>>>3  ^ w6<<25 ^ w6<<14 ) + ( w3>>>17 ^ w3>>>19 ^ w3>>>10 ^ w3<<15 ^ w3<<13 ) + w5 + w14 )|0;
            c = ( w5 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0x4a7484aa )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 22
            w6 = ( ( w7>>>7  ^ w7>>>18 ^ w7>>>3  ^ w7<<25 ^ w7<<14 ) + ( w4>>>17 ^ w4>>>19 ^ w4>>>10 ^ w4<<15 ^ w4<<13 ) + w6 + w15 )|0;
            b = ( w6 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0x5cb0a9dc )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 23
            w7 = ( ( w8>>>7  ^ w8>>>18 ^ w8>>>3  ^ w8<<25 ^ w8<<14 ) + ( w5>>>17 ^ w5>>>19 ^ w5>>>10 ^ w5<<15 ^ w5<<13 ) + w7 + w0 )|0;
            a = ( w7 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0x76f988da )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            // 24
            w8 = ( ( w9>>>7  ^ w9>>>18 ^ w9>>>3  ^ w9<<25 ^ w9<<14 ) + ( w6>>>17 ^ w6>>>19 ^ w6>>>10 ^ w6<<15 ^ w6<<13 ) + w8 + w1 )|0;
            h = ( w8 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0x983e5152 )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 25
            w9 = ( ( w10>>>7  ^ w10>>>18 ^ w10>>>3  ^ w10<<25 ^ w10<<14 ) + ( w7>>>17 ^ w7>>>19 ^ w7>>>10 ^ w7<<15 ^ w7<<13 ) + w9 + w2 )|0;
            g = ( w9 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0xa831c66d )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 26
            w10 = ( ( w11>>>7  ^ w11>>>18 ^ w11>>>3  ^ w11<<25 ^ w11<<14 ) + ( w8>>>17 ^ w8>>>19 ^ w8>>>10 ^ w8<<15 ^ w8<<13 ) + w10 + w3 )|0;
            f = ( w10 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0xb00327c8 )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 27
            w11 = ( ( w12>>>7  ^ w12>>>18 ^ w12>>>3  ^ w12<<25 ^ w12<<14 ) + ( w9>>>17 ^ w9>>>19 ^ w9>>>10 ^ w9<<15 ^ w9<<13 ) + w11 + w4 )|0;
            e = ( w11 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0xbf597fc7 )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 28
            w12 = ( ( w13>>>7  ^ w13>>>18 ^ w13>>>3  ^ w13<<25 ^ w13<<14 ) + ( w10>>>17 ^ w10>>>19 ^ w10>>>10 ^ w10<<15 ^ w10<<13 ) + w12 + w5 )|0;
            d = ( w12 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0xc6e00bf3 )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 29
            w13 = ( ( w14>>>7  ^ w14>>>18 ^ w14>>>3  ^ w14<<25 ^ w14<<14 ) + ( w11>>>17 ^ w11>>>19 ^ w11>>>10 ^ w11<<15 ^ w11<<13 ) + w13 + w6 )|0;
            c = ( w13 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0xd5a79147 )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 30
            w14 = ( ( w15>>>7  ^ w15>>>18 ^ w15>>>3  ^ w15<<25 ^ w15<<14 ) + ( w12>>>17 ^ w12>>>19 ^ w12>>>10 ^ w12<<15 ^ w12<<13 ) + w14 + w7 )|0;
            b = ( w14 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0x06ca6351 )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 31
            w15 = ( ( w0>>>7  ^ w0>>>18 ^ w0>>>3  ^ w0<<25 ^ w0<<14 ) + ( w13>>>17 ^ w13>>>19 ^ w13>>>10 ^ w13<<15 ^ w13<<13 ) + w15 + w8 )|0;
            a = ( w15 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0x14292967 )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            // 32
            w0 = ( ( w1>>>7  ^ w1>>>18 ^ w1>>>3  ^ w1<<25 ^ w1<<14 ) + ( w14>>>17 ^ w14>>>19 ^ w14>>>10 ^ w14<<15 ^ w14<<13 ) + w0 + w9 )|0;
            h = ( w0 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0x27b70a85 )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 33
            w1 = ( ( w2>>>7  ^ w2>>>18 ^ w2>>>3  ^ w2<<25 ^ w2<<14 ) + ( w15>>>17 ^ w15>>>19 ^ w15>>>10 ^ w15<<15 ^ w15<<13 ) + w1 + w10 )|0;
            g = ( w1 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0x2e1b2138 )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 34
            w2 = ( ( w3>>>7  ^ w3>>>18 ^ w3>>>3  ^ w3<<25 ^ w3<<14 ) + ( w0>>>17 ^ w0>>>19 ^ w0>>>10 ^ w0<<15 ^ w0<<13 ) + w2 + w11 )|0;
            f = ( w2 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0x4d2c6dfc )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 35
            w3 = ( ( w4>>>7  ^ w4>>>18 ^ w4>>>3  ^ w4<<25 ^ w4<<14 ) + ( w1>>>17 ^ w1>>>19 ^ w1>>>10 ^ w1<<15 ^ w1<<13 ) + w3 + w12 )|0;
            e = ( w3 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0x53380d13 )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 36
            w4 = ( ( w5>>>7  ^ w5>>>18 ^ w5>>>3  ^ w5<<25 ^ w5<<14 ) + ( w2>>>17 ^ w2>>>19 ^ w2>>>10 ^ w2<<15 ^ w2<<13 ) + w4 + w13 )|0;
            d = ( w4 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0x650a7354 )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 37
            w5 = ( ( w6>>>7  ^ w6>>>18 ^ w6>>>3  ^ w6<<25 ^ w6<<14 ) + ( w3>>>17 ^ w3>>>19 ^ w3>>>10 ^ w3<<15 ^ w3<<13 ) + w5 + w14 )|0;
            c = ( w5 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0x766a0abb )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 38
            w6 = ( ( w7>>>7  ^ w7>>>18 ^ w7>>>3  ^ w7<<25 ^ w7<<14 ) + ( w4>>>17 ^ w4>>>19 ^ w4>>>10 ^ w4<<15 ^ w4<<13 ) + w6 + w15 )|0;
            b = ( w6 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0x81c2c92e )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 39
            w7 = ( ( w8>>>7  ^ w8>>>18 ^ w8>>>3  ^ w8<<25 ^ w8<<14 ) + ( w5>>>17 ^ w5>>>19 ^ w5>>>10 ^ w5<<15 ^ w5<<13 ) + w7 + w0 )|0;
            a = ( w7 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0x92722c85 )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            // 40
            w8 = ( ( w9>>>7  ^ w9>>>18 ^ w9>>>3  ^ w9<<25 ^ w9<<14 ) + ( w6>>>17 ^ w6>>>19 ^ w6>>>10 ^ w6<<15 ^ w6<<13 ) + w8 + w1 )|0;
            h = ( w8 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0xa2bfe8a1 )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 41
            w9 = ( ( w10>>>7  ^ w10>>>18 ^ w10>>>3  ^ w10<<25 ^ w10<<14 ) + ( w7>>>17 ^ w7>>>19 ^ w7>>>10 ^ w7<<15 ^ w7<<13 ) + w9 + w2 )|0;
            g = ( w9 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0xa81a664b )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 42
            w10 = ( ( w11>>>7  ^ w11>>>18 ^ w11>>>3  ^ w11<<25 ^ w11<<14 ) + ( w8>>>17 ^ w8>>>19 ^ w8>>>10 ^ w8<<15 ^ w8<<13 ) + w10 + w3 )|0;
            f = ( w10 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0xc24b8b70 )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 43
            w11 = ( ( w12>>>7  ^ w12>>>18 ^ w12>>>3  ^ w12<<25 ^ w12<<14 ) + ( w9>>>17 ^ w9>>>19 ^ w9>>>10 ^ w9<<15 ^ w9<<13 ) + w11 + w4 )|0;
            e = ( w11 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0xc76c51a3 )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 44
            w12 = ( ( w13>>>7  ^ w13>>>18 ^ w13>>>3  ^ w13<<25 ^ w13<<14 ) + ( w10>>>17 ^ w10>>>19 ^ w10>>>10 ^ w10<<15 ^ w10<<13 ) + w12 + w5 )|0;
            d = ( w12 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0xd192e819 )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 45
            w13 = ( ( w14>>>7  ^ w14>>>18 ^ w14>>>3  ^ w14<<25 ^ w14<<14 ) + ( w11>>>17 ^ w11>>>19 ^ w11>>>10 ^ w11<<15 ^ w11<<13 ) + w13 + w6 )|0;
            c = ( w13 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0xd6990624 )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 46
            w14 = ( ( w15>>>7  ^ w15>>>18 ^ w15>>>3  ^ w15<<25 ^ w15<<14 ) + ( w12>>>17 ^ w12>>>19 ^ w12>>>10 ^ w12<<15 ^ w12<<13 ) + w14 + w7 )|0;
            b = ( w14 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0xf40e3585 )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 47
            w15 = ( ( w0>>>7  ^ w0>>>18 ^ w0>>>3  ^ w0<<25 ^ w0<<14 ) + ( w13>>>17 ^ w13>>>19 ^ w13>>>10 ^ w13<<15 ^ w13<<13 ) + w15 + w8 )|0;
            a = ( w15 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0x106aa070 )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            // 48
            w0 = ( ( w1>>>7  ^ w1>>>18 ^ w1>>>3  ^ w1<<25 ^ w1<<14 ) + ( w14>>>17 ^ w14>>>19 ^ w14>>>10 ^ w14<<15 ^ w14<<13 ) + w0 + w9 )|0;
            h = ( w0 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0x19a4c116 )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 49
            w1 = ( ( w2>>>7  ^ w2>>>18 ^ w2>>>3  ^ w2<<25 ^ w2<<14 ) + ( w15>>>17 ^ w15>>>19 ^ w15>>>10 ^ w15<<15 ^ w15<<13 ) + w1 + w10 )|0;
            g = ( w1 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0x1e376c08 )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 50
            w2 = ( ( w3>>>7  ^ w3>>>18 ^ w3>>>3  ^ w3<<25 ^ w3<<14 ) + ( w0>>>17 ^ w0>>>19 ^ w0>>>10 ^ w0<<15 ^ w0<<13 ) + w2 + w11 )|0;
            f = ( w2 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0x2748774c )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 51
            w3 = ( ( w4>>>7  ^ w4>>>18 ^ w4>>>3  ^ w4<<25 ^ w4<<14 ) + ( w1>>>17 ^ w1>>>19 ^ w1>>>10 ^ w1<<15 ^ w1<<13 ) + w3 + w12 )|0;
            e = ( w3 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0x34b0bcb5 )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 52
            w4 = ( ( w5>>>7  ^ w5>>>18 ^ w5>>>3  ^ w5<<25 ^ w5<<14 ) + ( w2>>>17 ^ w2>>>19 ^ w2>>>10 ^ w2<<15 ^ w2<<13 ) + w4 + w13 )|0;
            d = ( w4 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0x391c0cb3 )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 53
            w5 = ( ( w6>>>7  ^ w6>>>18 ^ w6>>>3  ^ w6<<25 ^ w6<<14 ) + ( w3>>>17 ^ w3>>>19 ^ w3>>>10 ^ w3<<15 ^ w3<<13 ) + w5 + w14 )|0;
            c = ( w5 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0x4ed8aa4a )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 54
            w6 = ( ( w7>>>7  ^ w7>>>18 ^ w7>>>3  ^ w7<<25 ^ w7<<14 ) + ( w4>>>17 ^ w4>>>19 ^ w4>>>10 ^ w4<<15 ^ w4<<13 ) + w6 + w15 )|0;
            b = ( w6 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0x5b9cca4f )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 55
            w7 = ( ( w8>>>7  ^ w8>>>18 ^ w8>>>3  ^ w8<<25 ^ w8<<14 ) + ( w5>>>17 ^ w5>>>19 ^ w5>>>10 ^ w5<<15 ^ w5<<13 ) + w7 + w0 )|0;
            a = ( w7 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0x682e6ff3 )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            // 56
            w8 = ( ( w9>>>7  ^ w9>>>18 ^ w9>>>3  ^ w9<<25 ^ w9<<14 ) + ( w6>>>17 ^ w6>>>19 ^ w6>>>10 ^ w6<<15 ^ w6<<13 ) + w8 + w1 )|0;
            h = ( w8 + h + ( e>>>6 ^ e>>>11 ^ e>>>25 ^ e<<26 ^ e<<21 ^ e<<7 ) +  ( g ^ e & (f^g) ) + 0x748f82ee )|0;
            d = ( d + h )|0;
            h = ( h + ( (a & b) ^ ( c & (a ^ b) ) ) + ( a>>>2 ^ a>>>13 ^ a>>>22 ^ a<<30 ^ a<<19 ^ a<<10 ) )|0;

            // 57
            w9 = ( ( w10>>>7  ^ w10>>>18 ^ w10>>>3  ^ w10<<25 ^ w10<<14 ) + ( w7>>>17 ^ w7>>>19 ^ w7>>>10 ^ w7<<15 ^ w7<<13 ) + w9 + w2 )|0;
            g = ( w9 + g + ( d>>>6 ^ d>>>11 ^ d>>>25 ^ d<<26 ^ d<<21 ^ d<<7 ) +  ( f ^ d & (e^f) ) + 0x78a5636f )|0;
            c = ( c + g )|0;
            g = ( g + ( (h & a) ^ ( b & (h ^ a) ) ) + ( h>>>2 ^ h>>>13 ^ h>>>22 ^ h<<30 ^ h<<19 ^ h<<10 ) )|0;

            // 58
            w10 = ( ( w11>>>7  ^ w11>>>18 ^ w11>>>3  ^ w11<<25 ^ w11<<14 ) + ( w8>>>17 ^ w8>>>19 ^ w8>>>10 ^ w8<<15 ^ w8<<13 ) + w10 + w3 )|0;
            f = ( w10 + f + ( c>>>6 ^ c>>>11 ^ c>>>25 ^ c<<26 ^ c<<21 ^ c<<7 ) +  ( e ^ c & (d^e) ) + 0x84c87814 )|0;
            b = ( b + f )|0;
            f = ( f + ( (g & h) ^ ( a & (g ^ h) ) ) + ( g>>>2 ^ g>>>13 ^ g>>>22 ^ g<<30 ^ g<<19 ^ g<<10 ) )|0;

            // 59
            w11 = ( ( w12>>>7  ^ w12>>>18 ^ w12>>>3  ^ w12<<25 ^ w12<<14 ) + ( w9>>>17 ^ w9>>>19 ^ w9>>>10 ^ w9<<15 ^ w9<<13 ) + w11 + w4 )|0;
            e = ( w11 + e + ( b>>>6 ^ b>>>11 ^ b>>>25 ^ b<<26 ^ b<<21 ^ b<<7 ) +  ( d ^ b & (c^d) ) + 0x8cc70208 )|0;
            a = ( a + e )|0;
            e = ( e + ( (f & g) ^ ( h & (f ^ g) ) ) + ( f>>>2 ^ f>>>13 ^ f>>>22 ^ f<<30 ^ f<<19 ^ f<<10 ) )|0;

            // 60
            w12 = ( ( w13>>>7  ^ w13>>>18 ^ w13>>>3  ^ w13<<25 ^ w13<<14 ) + ( w10>>>17 ^ w10>>>19 ^ w10>>>10 ^ w10<<15 ^ w10<<13 ) + w12 + w5 )|0;
            d = ( w12 + d + ( a>>>6 ^ a>>>11 ^ a>>>25 ^ a<<26 ^ a<<21 ^ a<<7 ) +  ( c ^ a & (b^c) ) + 0x90befffa )|0;
            h = ( h + d )|0;
            d = ( d + ( (e & f) ^ ( g & (e ^ f) ) ) + ( e>>>2 ^ e>>>13 ^ e>>>22 ^ e<<30 ^ e<<19 ^ e<<10 ) )|0;

            // 61
            w13 = ( ( w14>>>7  ^ w14>>>18 ^ w14>>>3  ^ w14<<25 ^ w14<<14 ) + ( w11>>>17 ^ w11>>>19 ^ w11>>>10 ^ w11<<15 ^ w11<<13 ) + w13 + w6 )|0;
            c = ( w13 + c + ( h>>>6 ^ h>>>11 ^ h>>>25 ^ h<<26 ^ h<<21 ^ h<<7 ) +  ( b ^ h & (a^b) ) + 0xa4506ceb )|0;
            g = ( g + c )|0;
            c = ( c + ( (d & e) ^ ( f & (d ^ e) ) ) + ( d>>>2 ^ d>>>13 ^ d>>>22 ^ d<<30 ^ d<<19 ^ d<<10 ) )|0;

            // 62
            w14 = ( ( w15>>>7  ^ w15>>>18 ^ w15>>>3  ^ w15<<25 ^ w15<<14 ) + ( w12>>>17 ^ w12>>>19 ^ w12>>>10 ^ w12<<15 ^ w12<<13 ) + w14 + w7 )|0;
            b = ( w14 + b + ( g>>>6 ^ g>>>11 ^ g>>>25 ^ g<<26 ^ g<<21 ^ g<<7 ) +  ( a ^ g & (h^a) ) + 0xbef9a3f7 )|0;
            f = ( f + b )|0;
            b = ( b + ( (c & d) ^ ( e & (c ^ d) ) ) + ( c>>>2 ^ c>>>13 ^ c>>>22 ^ c<<30 ^ c<<19 ^ c<<10 ) )|0;

            // 63
            w15 = ( ( w0>>>7  ^ w0>>>18 ^ w0>>>3  ^ w0<<25 ^ w0<<14 ) + ( w13>>>17 ^ w13>>>19 ^ w13>>>10 ^ w13<<15 ^ w13<<13 ) + w15 + w8 )|0;
            a = ( w15 + a + ( f>>>6 ^ f>>>11 ^ f>>>25 ^ f<<26 ^ f<<21 ^ f<<7 ) +  ( h ^ f & (g^h) ) + 0xc67178f2 )|0;
            e = ( e + a )|0;
            a = ( a + ( (b & c) ^ ( d & (b ^ c) ) ) + ( b>>>2 ^ b>>>13 ^ b>>>22 ^ b<<30 ^ b<<19 ^ b<<10 ) )|0;

            H0 = ( H0 + a )|0;
            H1 = ( H1 + b )|0;
            H2 = ( H2 + c )|0;
            H3 = ( H3 + d )|0;
            H4 = ( H4 + e )|0;
            H5 = ( H5 + f )|0;
            H6 = ( H6 + g )|0;
            H7 = ( H7 + h )|0;
        }

        function _core_heap ( offset ) {
            offset = offset|0;

            _core(
                HEAP[offset|0]<<24 | HEAP[offset|1]<<16 | HEAP[offset|2]<<8 | HEAP[offset|3],
                HEAP[offset|4]<<24 | HEAP[offset|5]<<16 | HEAP[offset|6]<<8 | HEAP[offset|7],
                HEAP[offset|8]<<24 | HEAP[offset|9]<<16 | HEAP[offset|10]<<8 | HEAP[offset|11],
                HEAP[offset|12]<<24 | HEAP[offset|13]<<16 | HEAP[offset|14]<<8 | HEAP[offset|15],
                HEAP[offset|16]<<24 | HEAP[offset|17]<<16 | HEAP[offset|18]<<8 | HEAP[offset|19],
                HEAP[offset|20]<<24 | HEAP[offset|21]<<16 | HEAP[offset|22]<<8 | HEAP[offset|23],
                HEAP[offset|24]<<24 | HEAP[offset|25]<<16 | HEAP[offset|26]<<8 | HEAP[offset|27],
                HEAP[offset|28]<<24 | HEAP[offset|29]<<16 | HEAP[offset|30]<<8 | HEAP[offset|31],
                HEAP[offset|32]<<24 | HEAP[offset|33]<<16 | HEAP[offset|34]<<8 | HEAP[offset|35],
                HEAP[offset|36]<<24 | HEAP[offset|37]<<16 | HEAP[offset|38]<<8 | HEAP[offset|39],
                HEAP[offset|40]<<24 | HEAP[offset|41]<<16 | HEAP[offset|42]<<8 | HEAP[offset|43],
                HEAP[offset|44]<<24 | HEAP[offset|45]<<16 | HEAP[offset|46]<<8 | HEAP[offset|47],
                HEAP[offset|48]<<24 | HEAP[offset|49]<<16 | HEAP[offset|50]<<8 | HEAP[offset|51],
                HEAP[offset|52]<<24 | HEAP[offset|53]<<16 | HEAP[offset|54]<<8 | HEAP[offset|55],
                HEAP[offset|56]<<24 | HEAP[offset|57]<<16 | HEAP[offset|58]<<8 | HEAP[offset|59],
                HEAP[offset|60]<<24 | HEAP[offset|61]<<16 | HEAP[offset|62]<<8 | HEAP[offset|63]
            );
        }

        // offset — multiple of 32
        function _state_to_heap ( output ) {
            output = output|0;

            HEAP[output|0] = H0>>>24;
            HEAP[output|1] = H0>>>16&255;
            HEAP[output|2] = H0>>>8&255;
            HEAP[output|3] = H0&255;
            HEAP[output|4] = H1>>>24;
            HEAP[output|5] = H1>>>16&255;
            HEAP[output|6] = H1>>>8&255;
            HEAP[output|7] = H1&255;
            HEAP[output|8] = H2>>>24;
            HEAP[output|9] = H2>>>16&255;
            HEAP[output|10] = H2>>>8&255;
            HEAP[output|11] = H2&255;
            HEAP[output|12] = H3>>>24;
            HEAP[output|13] = H3>>>16&255;
            HEAP[output|14] = H3>>>8&255;
            HEAP[output|15] = H3&255;
            HEAP[output|16] = H4>>>24;
            HEAP[output|17] = H4>>>16&255;
            HEAP[output|18] = H4>>>8&255;
            HEAP[output|19] = H4&255;
            HEAP[output|20] = H5>>>24;
            HEAP[output|21] = H5>>>16&255;
            HEAP[output|22] = H5>>>8&255;
            HEAP[output|23] = H5&255;
            HEAP[output|24] = H6>>>24;
            HEAP[output|25] = H6>>>16&255;
            HEAP[output|26] = H6>>>8&255;
            HEAP[output|27] = H6&255;
            HEAP[output|28] = H7>>>24;
            HEAP[output|29] = H7>>>16&255;
            HEAP[output|30] = H7>>>8&255;
            HEAP[output|31] = H7&255;
        }

        function reset () {
            H0 = 0x6a09e667;
            H1 = 0xbb67ae85;
            H2 = 0x3c6ef372;
            H3 = 0xa54ff53a;
            H4 = 0x510e527f;
            H5 = 0x9b05688c;
            H6 = 0x1f83d9ab;
            H7 = 0x5be0cd19;
            TOTAL0 = TOTAL1 = 0;
        }

        function init ( h0, h1, h2, h3, h4, h5, h6, h7, total0, total1 ) {
            h0 = h0|0;
            h1 = h1|0;
            h2 = h2|0;
            h3 = h3|0;
            h4 = h4|0;
            h5 = h5|0;
            h6 = h6|0;
            h7 = h7|0;
            total0 = total0|0;
            total1 = total1|0;

            H0 = h0;
            H1 = h1;
            H2 = h2;
            H3 = h3;
            H4 = h4;
            H5 = h5;
            H6 = h6;
            H7 = h7;
            TOTAL0 = total0;
            TOTAL1 = total1;
        }

        // offset — multiple of 64
        function process ( offset, length ) {
            offset = offset|0;
            length = length|0;

            var hashed = 0;

            if ( offset & 63 )
                return -1;

            while ( (length|0) >= 64 ) {
                _core_heap(offset);

                offset = ( offset + 64 )|0;
                length = ( length - 64 )|0;

                hashed = ( hashed + 64 )|0;
            }

            TOTAL0 = ( TOTAL0 + hashed )|0;
            if ( TOTAL0>>>0 < hashed>>>0 ) TOTAL1 = ( TOTAL1 + 1 )|0;

            return hashed|0;
        }

        // offset — multiple of 64
        // output — multiple of 32
        function finish ( offset, length, output ) {
            offset = offset|0;
            length = length|0;
            output = output|0;

            var hashed = 0,
                i = 0;

            if ( offset & 63 )
                return -1;

            if ( ~output )
                if ( output & 31 )
                    return -1;

            if ( (length|0) >= 64 ) {
                hashed = process( offset, length )|0;
                if ( (hashed|0) == -1 )
                    return -1;

                offset = ( offset + hashed )|0;
                length = ( length - hashed )|0;
            }

            hashed = ( hashed + length )|0;
            TOTAL0 = ( TOTAL0 + length )|0;
            if ( TOTAL0>>>0 < length>>>0 ) TOTAL1 = ( TOTAL1 + 1 )|0;

            HEAP[offset|length] = 0x80;

            if ( (length|0) >= 56 ) {
                for ( i = (length+1)|0; (i|0) < 64; i = (i+1)|0 )
                    HEAP[offset|i] = 0x00;

                _core_heap(offset);

                length = 0;

                HEAP[offset|0] = 0;
            }

            for ( i = (length+1)|0; (i|0) < 59; i = (i+1)|0 )
                HEAP[offset|i] = 0;

            HEAP[offset|56] = TOTAL1>>>21&255;
            HEAP[offset|57] = TOTAL1>>>13&255;
            HEAP[offset|58] = TOTAL1>>>5&255;
            HEAP[offset|59] = TOTAL1<<3&255 | TOTAL0>>>29;
            HEAP[offset|60] = TOTAL0>>>21&255;
            HEAP[offset|61] = TOTAL0>>>13&255;
            HEAP[offset|62] = TOTAL0>>>5&255;
            HEAP[offset|63] = TOTAL0<<3&255;
            _core_heap(offset);

            if ( ~output )
                _state_to_heap(output);

            return hashed|0;
        }

        function hmac_reset () {
            H0 = I0;
            H1 = I1;
            H2 = I2;
            H3 = I3;
            H4 = I4;
            H5 = I5;
            H6 = I6;
            H7 = I7;
            TOTAL0 = 64;
            TOTAL1 = 0;
        }

        function _hmac_opad () {
            H0 = O0;
            H1 = O1;
            H2 = O2;
            H3 = O3;
            H4 = O4;
            H5 = O5;
            H6 = O6;
            H7 = O7;
            TOTAL0 = 64;
            TOTAL1 = 0;
        }

        function hmac_init ( p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15 ) {
            p0 = p0|0;
            p1 = p1|0;
            p2 = p2|0;
            p3 = p3|0;
            p4 = p4|0;
            p5 = p5|0;
            p6 = p6|0;
            p7 = p7|0;
            p8 = p8|0;
            p9 = p9|0;
            p10 = p10|0;
            p11 = p11|0;
            p12 = p12|0;
            p13 = p13|0;
            p14 = p14|0;
            p15 = p15|0;

            // opad
            reset();
            _core(
                p0 ^ 0x5c5c5c5c,
                p1 ^ 0x5c5c5c5c,
                p2 ^ 0x5c5c5c5c,
                p3 ^ 0x5c5c5c5c,
                p4 ^ 0x5c5c5c5c,
                p5 ^ 0x5c5c5c5c,
                p6 ^ 0x5c5c5c5c,
                p7 ^ 0x5c5c5c5c,
                p8 ^ 0x5c5c5c5c,
                p9 ^ 0x5c5c5c5c,
                p10 ^ 0x5c5c5c5c,
                p11 ^ 0x5c5c5c5c,
                p12 ^ 0x5c5c5c5c,
                p13 ^ 0x5c5c5c5c,
                p14 ^ 0x5c5c5c5c,
                p15 ^ 0x5c5c5c5c
            );
            O0 = H0;
            O1 = H1;
            O2 = H2;
            O3 = H3;
            O4 = H4;
            O5 = H5;
            O6 = H6;
            O7 = H7;

            // ipad
            reset();
            _core(
                p0 ^ 0x36363636,
                p1 ^ 0x36363636,
                p2 ^ 0x36363636,
                p3 ^ 0x36363636,
                p4 ^ 0x36363636,
                p5 ^ 0x36363636,
                p6 ^ 0x36363636,
                p7 ^ 0x36363636,
                p8 ^ 0x36363636,
                p9 ^ 0x36363636,
                p10 ^ 0x36363636,
                p11 ^ 0x36363636,
                p12 ^ 0x36363636,
                p13 ^ 0x36363636,
                p14 ^ 0x36363636,
                p15 ^ 0x36363636
            );
            I0 = H0;
            I1 = H1;
            I2 = H2;
            I3 = H3;
            I4 = H4;
            I5 = H5;
            I6 = H6;
            I7 = H7;

            TOTAL0 = 64;
            TOTAL1 = 0;
        }

        // offset — multiple of 64
        // output — multiple of 32
        function hmac_finish ( offset, length, output ) {
            offset = offset|0;
            length = length|0;
            output = output|0;

            var t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0,
                hashed = 0;

            if ( offset & 63 )
                return -1;

            if ( ~output )
                if ( output & 31 )
                    return -1;

            hashed = finish( offset, length, -1 )|0;
            t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4, t5 = H5, t6 = H6, t7 = H7;

            _hmac_opad();
            _core( t0, t1, t2, t3, t4, t5, t6, t7, 0x80000000, 0, 0, 0, 0, 0, 0, 768 );

            if ( ~output )
                _state_to_heap(output);

            return hashed|0;
        }

        // salt is assumed to be already processed
        // offset — multiple of 64
        // output — multiple of 32
        function pbkdf2_generate_block ( offset, length, block, count, output ) {
            offset = offset|0;
            length = length|0;
            block = block|0;
            count = count|0;
            output = output|0;

            var h0 = 0, h1 = 0, h2 = 0, h3 = 0, h4 = 0, h5 = 0, h6 = 0, h7 = 0,
                t0 = 0, t1 = 0, t2 = 0, t3 = 0, t4 = 0, t5 = 0, t6 = 0, t7 = 0;

            if ( offset & 63 )
                return -1;

            if ( ~output )
                if ( output & 31 )
                    return -1;

            // pad block number into heap
            // FIXME probable OOB write
            HEAP[(offset+length)|0]   = block>>>24;
            HEAP[(offset+length+1)|0] = block>>>16&255;
            HEAP[(offset+length+2)|0] = block>>>8&255;
            HEAP[(offset+length+3)|0] = block&255;

            // finish first iteration
            hmac_finish( offset, (length+4)|0, -1 )|0;
            h0 = t0 = H0, h1 = t1 = H1, h2 = t2 = H2, h3 = t3 = H3, h4 = t4 = H4, h5 = t5 = H5, h6 = t6 = H6, h7 = t7 = H7;
            count = (count-1)|0;

            // perform the rest iterations
            while ( (count|0) > 0 ) {
                hmac_reset();
                _core( t0, t1, t2, t3, t4, t5, t6, t7, 0x80000000, 0, 0, 0, 0, 0, 0, 768 );
                t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4, t5 = H5, t6 = H6, t7 = H7;

                _hmac_opad();
                _core( t0, t1, t2, t3, t4, t5, t6, t7, 0x80000000, 0, 0, 0, 0, 0, 0, 768 );
                t0 = H0, t1 = H1, t2 = H2, t3 = H3, t4 = H4, t5 = H5, t6 = H6, t7 = H7;

                h0 = h0 ^ H0;
                h1 = h1 ^ H1;
                h2 = h2 ^ H2;
                h3 = h3 ^ H3;
                h4 = h4 ^ H4;
                h5 = h5 ^ H5;
                h6 = h6 ^ H6;
                h7 = h7 ^ H7;

                count = (count-1)|0;
            }

            H0 = h0;
            H1 = h1;
            H2 = h2;
            H3 = h3;
            H4 = h4;
            H5 = h5;
            H6 = h6;
            H7 = h7;

            if ( ~output )
                _state_to_heap(output);

            return 0;
        }

        return {
          // SHA256
          reset: reset,
          init: init,
          process: process,
          finish: finish,

          // HMAC-SHA256
          hmac_reset: hmac_reset,
          hmac_init: hmac_init,
          hmac_finish: hmac_finish,

          // PBKDF2-HMAC-SHA256
          pbkdf2_generate_block: pbkdf2_generate_block
        }
    };

    var __extends$3 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var _sha256_block_size = 64;
    var _sha256_hash_size = 32;
    var Sha256 = /** @class */ (function (_super) {
        __extends$3(Sha256, _super);
        function Sha256() {
            var _this = _super.call(this) || this;
            _this.NAME = 'sha256';
            _this.BLOCK_SIZE = _sha256_block_size;
            _this.HASH_SIZE = _sha256_hash_size;
            _this.heap = _heap_init();
            _this.asm = sha256_asm({ Uint8Array: Uint8Array }, null, _this.heap.buffer);
            _this.reset();
            return _this;
        }
        Sha256.NAME = 'sha256';
        return Sha256;
    }(Hash));

    var sha512_asm = function ( stdlib, foreign, buffer ) {
        "use asm";

        // SHA512 state
        var H0h = 0, H0l = 0, H1h = 0, H1l = 0, H2h = 0, H2l = 0, H3h = 0, H3l = 0,
            H4h = 0, H4l = 0, H5h = 0, H5l = 0, H6h = 0, H6l = 0, H7h = 0, H7l = 0,
            TOTAL0 = 0, TOTAL1 = 0;

        // HMAC state
        var I0h = 0, I0l = 0, I1h = 0, I1l = 0, I2h = 0, I2l = 0, I3h = 0, I3l = 0,
            I4h = 0, I4l = 0, I5h = 0, I5l = 0, I6h = 0, I6l = 0, I7h = 0, I7l = 0,
            O0h = 0, O0l = 0, O1h = 0, O1l = 0, O2h = 0, O2l = 0, O3h = 0, O3l = 0,
            O4h = 0, O4l = 0, O5h = 0, O5l = 0, O6h = 0, O6l = 0, O7h = 0, O7l = 0;

        // I/O buffer
        var HEAP = new stdlib.Uint8Array(buffer);

        function _core ( w0h, w0l, w1h, w1l, w2h, w2l, w3h, w3l, w4h, w4l, w5h, w5l, w6h, w6l, w7h, w7l, w8h, w8l, w9h, w9l, w10h, w10l, w11h, w11l, w12h, w12l, w13h, w13l, w14h, w14l, w15h, w15l ) {
            w0h = w0h|0;
            w0l = w0l|0;
            w1h = w1h|0;
            w1l = w1l|0;
            w2h = w2h|0;
            w2l = w2l|0;
            w3h = w3h|0;
            w3l = w3l|0;
            w4h = w4h|0;
            w4l = w4l|0;
            w5h = w5h|0;
            w5l = w5l|0;
            w6h = w6h|0;
            w6l = w6l|0;
            w7h = w7h|0;
            w7l = w7l|0;
            w8h = w8h|0;
            w8l = w8l|0;
            w9h = w9h|0;
            w9l = w9l|0;
            w10h = w10h|0;
            w10l = w10l|0;
            w11h = w11h|0;
            w11l = w11l|0;
            w12h = w12h|0;
            w12l = w12l|0;
            w13h = w13h|0;
            w13l = w13l|0;
            w14h = w14h|0;
            w14l = w14l|0;
            w15h = w15h|0;
            w15l = w15l|0;

            var ah = 0, al = 0, bh = 0, bl = 0, ch = 0, cl = 0, dh = 0, dl = 0, eh = 0, el = 0, fh = 0, fl = 0, gh = 0, gl = 0, hh = 0, hl = 0,
                th = 0, tl = 0, xl = 0;

            ah = H0h;
            al = H0l;
            bh = H1h;
            bl = H1l;
            ch = H2h;
            cl = H2l;
            dh = H3h;
            dl = H3l;
            eh = H4h;
            el = H4l;
            fh = H5h;
            fl = H5l;
            gh = H6h;
            gl = H6l;
            hh = H7h;
            hl = H7l;

            // 0
            tl = ( 0xd728ae22 + w0l )|0;
            th = ( 0x428a2f98 + w0h + ((tl >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 1
            tl = ( 0x23ef65cd + w1l )|0;
            th = ( 0x71374491 + w1h + ((tl >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 2
            tl = ( 0xec4d3b2f + w2l )|0;
            th = ( 0xb5c0fbcf + w2h + ((tl >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 3
            tl = ( 0x8189dbbc + w3l )|0;
            th = ( 0xe9b5dba5 + w3h + ((tl >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 4
            tl = ( 0xf348b538 + w4l )|0;
            th = ( 0x3956c25b + w4h + ((tl >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 5
            tl = ( 0xb605d019 + w5l )|0;
            th = ( 0x59f111f1 + w5h + ((tl >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 6
            tl = ( 0xaf194f9b + w6l )|0;
            th = ( 0x923f82a4 + w6h + ((tl >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 7
            tl = ( 0xda6d8118 + w7l )|0;
            th = ( 0xab1c5ed5 + w7h + ((tl >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 8
            tl = ( 0xa3030242 + w8l )|0;
            th = ( 0xd807aa98 + w8h + ((tl >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 9
            tl = ( 0x45706fbe + w9l )|0;
            th = ( 0x12835b01 + w9h + ((tl >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 10
            tl = ( 0x4ee4b28c + w10l )|0;
            th = ( 0x243185be + w10h + ((tl >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 11
            tl = ( 0xd5ffb4e2 + w11l )|0;
            th = ( 0x550c7dc3 + w11h + ((tl >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 12
            tl = ( 0xf27b896f + w12l )|0;
            th = ( 0x72be5d74 + w12h + ((tl >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 13
            tl = ( 0x3b1696b1 + w13l )|0;
            th = ( 0x80deb1fe + w13h + ((tl >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 14
            tl = ( 0x25c71235 + w14l )|0;
            th = ( 0x9bdc06a7 + w14h + ((tl >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 15
            tl = ( 0xcf692694 + w15l )|0;
            th = ( 0xc19bf174 + w15h + ((tl >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 16
            w0l = ( w0l + w9l )|0;
            w0h = ( w0h + w9h + ((w0l >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 1) | (w1h << 31)) ^ ((w1l >>> 8) | (w1h << 24)) ^ ((w1l >>> 7) | (w1h << 25)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w1h >>> 1) | (w1l << 31)) ^ ((w1h >>> 8) | (w1l << 24)) ^ (w1h >>> 7) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 19) | (w14h << 13)) ^ ((w14l << 3) | (w14h >>> 29)) ^ ((w14l >>> 6) | (w14h << 26)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w14h >>> 19) | (w14l << 13)) ^ ((w14h << 3) | (w14l >>> 29)) ^ (w14h >>> 6) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x9ef14ad2 + w0l )|0;
            th = ( 0xe49b69c1 + w0h + ((tl >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 17
            w1l = ( w1l + w10l )|0;
            w1h = ( w1h + w10h + ((w1l >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 1) | (w2h << 31)) ^ ((w2l >>> 8) | (w2h << 24)) ^ ((w2l >>> 7) | (w2h << 25)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w2h >>> 1) | (w2l << 31)) ^ ((w2h >>> 8) | (w2l << 24)) ^ (w2h >>> 7) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 19) | (w15h << 13)) ^ ((w15l << 3) | (w15h >>> 29)) ^ ((w15l >>> 6) | (w15h << 26)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w15h >>> 19) | (w15l << 13)) ^ ((w15h << 3) | (w15l >>> 29)) ^ (w15h >>> 6) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x384f25e3 + w1l )|0;
            th = ( 0xefbe4786 + w1h + ((tl >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 18
            w2l = ( w2l + w11l )|0;
            w2h = ( w2h + w11h + ((w2l >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 1) | (w3h << 31)) ^ ((w3l >>> 8) | (w3h << 24)) ^ ((w3l >>> 7) | (w3h << 25)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w3h >>> 1) | (w3l << 31)) ^ ((w3h >>> 8) | (w3l << 24)) ^ (w3h >>> 7) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 19) | (w0h << 13)) ^ ((w0l << 3) | (w0h >>> 29)) ^ ((w0l >>> 6) | (w0h << 26)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w0h >>> 19) | (w0l << 13)) ^ ((w0h << 3) | (w0l >>> 29)) ^ (w0h >>> 6) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x8b8cd5b5 + w2l )|0;
            th = ( 0xfc19dc6 + w2h + ((tl >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 19
            w3l = ( w3l + w12l )|0;
            w3h = ( w3h + w12h + ((w3l >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 1) | (w4h << 31)) ^ ((w4l >>> 8) | (w4h << 24)) ^ ((w4l >>> 7) | (w4h << 25)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w4h >>> 1) | (w4l << 31)) ^ ((w4h >>> 8) | (w4l << 24)) ^ (w4h >>> 7) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 19) | (w1h << 13)) ^ ((w1l << 3) | (w1h >>> 29)) ^ ((w1l >>> 6) | (w1h << 26)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w1h >>> 19) | (w1l << 13)) ^ ((w1h << 3) | (w1l >>> 29)) ^ (w1h >>> 6) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x77ac9c65 + w3l )|0;
            th = ( 0x240ca1cc + w3h + ((tl >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 20
            w4l = ( w4l + w13l )|0;
            w4h = ( w4h + w13h + ((w4l >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 1) | (w5h << 31)) ^ ((w5l >>> 8) | (w5h << 24)) ^ ((w5l >>> 7) | (w5h << 25)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w5h >>> 1) | (w5l << 31)) ^ ((w5h >>> 8) | (w5l << 24)) ^ (w5h >>> 7) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 19) | (w2h << 13)) ^ ((w2l << 3) | (w2h >>> 29)) ^ ((w2l >>> 6) | (w2h << 26)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w2h >>> 19) | (w2l << 13)) ^ ((w2h << 3) | (w2l >>> 29)) ^ (w2h >>> 6) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x592b0275 + w4l )|0;
            th = ( 0x2de92c6f + w4h + ((tl >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 21
            w5l = ( w5l + w14l )|0;
            w5h = ( w5h + w14h + ((w5l >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 1) | (w6h << 31)) ^ ((w6l >>> 8) | (w6h << 24)) ^ ((w6l >>> 7) | (w6h << 25)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w6h >>> 1) | (w6l << 31)) ^ ((w6h >>> 8) | (w6l << 24)) ^ (w6h >>> 7) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 19) | (w3h << 13)) ^ ((w3l << 3) | (w3h >>> 29)) ^ ((w3l >>> 6) | (w3h << 26)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w3h >>> 19) | (w3l << 13)) ^ ((w3h << 3) | (w3l >>> 29)) ^ (w3h >>> 6) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x6ea6e483 + w5l )|0;
            th = ( 0x4a7484aa + w5h + ((tl >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 22
            w6l = ( w6l + w15l )|0;
            w6h = ( w6h + w15h + ((w6l >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 1) | (w7h << 31)) ^ ((w7l >>> 8) | (w7h << 24)) ^ ((w7l >>> 7) | (w7h << 25)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w7h >>> 1) | (w7l << 31)) ^ ((w7h >>> 8) | (w7l << 24)) ^ (w7h >>> 7) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 19) | (w4h << 13)) ^ ((w4l << 3) | (w4h >>> 29)) ^ ((w4l >>> 6) | (w4h << 26)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w4h >>> 19) | (w4l << 13)) ^ ((w4h << 3) | (w4l >>> 29)) ^ (w4h >>> 6) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xbd41fbd4 + w6l )|0;
            th = ( 0x5cb0a9dc + w6h + ((tl >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 23
            w7l = ( w7l + w0l )|0;
            w7h = ( w7h + w0h + ((w7l >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 1) | (w8h << 31)) ^ ((w8l >>> 8) | (w8h << 24)) ^ ((w8l >>> 7) | (w8h << 25)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w8h >>> 1) | (w8l << 31)) ^ ((w8h >>> 8) | (w8l << 24)) ^ (w8h >>> 7) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 19) | (w5h << 13)) ^ ((w5l << 3) | (w5h >>> 29)) ^ ((w5l >>> 6) | (w5h << 26)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w5h >>> 19) | (w5l << 13)) ^ ((w5h << 3) | (w5l >>> 29)) ^ (w5h >>> 6) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x831153b5 + w7l )|0;
            th = ( 0x76f988da + w7h + ((tl >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 24
            w8l = ( w8l + w1l )|0;
            w8h = ( w8h + w1h + ((w8l >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 1) | (w9h << 31)) ^ ((w9l >>> 8) | (w9h << 24)) ^ ((w9l >>> 7) | (w9h << 25)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w9h >>> 1) | (w9l << 31)) ^ ((w9h >>> 8) | (w9l << 24)) ^ (w9h >>> 7) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 19) | (w6h << 13)) ^ ((w6l << 3) | (w6h >>> 29)) ^ ((w6l >>> 6) | (w6h << 26)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w6h >>> 19) | (w6l << 13)) ^ ((w6h << 3) | (w6l >>> 29)) ^ (w6h >>> 6) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xee66dfab + w8l )|0;
            th = ( 0x983e5152 + w8h + ((tl >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 25
            w9l = ( w9l + w2l )|0;
            w9h = ( w9h + w2h + ((w9l >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 1) | (w10h << 31)) ^ ((w10l >>> 8) | (w10h << 24)) ^ ((w10l >>> 7) | (w10h << 25)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w10h >>> 1) | (w10l << 31)) ^ ((w10h >>> 8) | (w10l << 24)) ^ (w10h >>> 7) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 19) | (w7h << 13)) ^ ((w7l << 3) | (w7h >>> 29)) ^ ((w7l >>> 6) | (w7h << 26)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w7h >>> 19) | (w7l << 13)) ^ ((w7h << 3) | (w7l >>> 29)) ^ (w7h >>> 6) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x2db43210 + w9l )|0;
            th = ( 0xa831c66d + w9h + ((tl >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 26
            w10l = ( w10l + w3l )|0;
            w10h = ( w10h + w3h + ((w10l >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 1) | (w11h << 31)) ^ ((w11l >>> 8) | (w11h << 24)) ^ ((w11l >>> 7) | (w11h << 25)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w11h >>> 1) | (w11l << 31)) ^ ((w11h >>> 8) | (w11l << 24)) ^ (w11h >>> 7) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 19) | (w8h << 13)) ^ ((w8l << 3) | (w8h >>> 29)) ^ ((w8l >>> 6) | (w8h << 26)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w8h >>> 19) | (w8l << 13)) ^ ((w8h << 3) | (w8l >>> 29)) ^ (w8h >>> 6) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x98fb213f + w10l )|0;
            th = ( 0xb00327c8 + w10h + ((tl >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 27
            w11l = ( w11l + w4l )|0;
            w11h = ( w11h + w4h + ((w11l >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 1) | (w12h << 31)) ^ ((w12l >>> 8) | (w12h << 24)) ^ ((w12l >>> 7) | (w12h << 25)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w12h >>> 1) | (w12l << 31)) ^ ((w12h >>> 8) | (w12l << 24)) ^ (w12h >>> 7) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 19) | (w9h << 13)) ^ ((w9l << 3) | (w9h >>> 29)) ^ ((w9l >>> 6) | (w9h << 26)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w9h >>> 19) | (w9l << 13)) ^ ((w9h << 3) | (w9l >>> 29)) ^ (w9h >>> 6) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xbeef0ee4 + w11l )|0;
            th = ( 0xbf597fc7 + w11h + ((tl >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 28
            w12l = ( w12l + w5l )|0;
            w12h = ( w12h + w5h + ((w12l >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 1) | (w13h << 31)) ^ ((w13l >>> 8) | (w13h << 24)) ^ ((w13l >>> 7) | (w13h << 25)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w13h >>> 1) | (w13l << 31)) ^ ((w13h >>> 8) | (w13l << 24)) ^ (w13h >>> 7) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 19) | (w10h << 13)) ^ ((w10l << 3) | (w10h >>> 29)) ^ ((w10l >>> 6) | (w10h << 26)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w10h >>> 19) | (w10l << 13)) ^ ((w10h << 3) | (w10l >>> 29)) ^ (w10h >>> 6) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x3da88fc2 + w12l )|0;
            th = ( 0xc6e00bf3 + w12h + ((tl >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 29
            w13l = ( w13l + w6l )|0;
            w13h = ( w13h + w6h + ((w13l >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 1) | (w14h << 31)) ^ ((w14l >>> 8) | (w14h << 24)) ^ ((w14l >>> 7) | (w14h << 25)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w14h >>> 1) | (w14l << 31)) ^ ((w14h >>> 8) | (w14l << 24)) ^ (w14h >>> 7) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 19) | (w11h << 13)) ^ ((w11l << 3) | (w11h >>> 29)) ^ ((w11l >>> 6) | (w11h << 26)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w11h >>> 19) | (w11l << 13)) ^ ((w11h << 3) | (w11l >>> 29)) ^ (w11h >>> 6) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x930aa725 + w13l )|0;
            th = ( 0xd5a79147 + w13h + ((tl >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 30
            w14l = ( w14l + w7l )|0;
            w14h = ( w14h + w7h + ((w14l >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 1) | (w15h << 31)) ^ ((w15l >>> 8) | (w15h << 24)) ^ ((w15l >>> 7) | (w15h << 25)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w15h >>> 1) | (w15l << 31)) ^ ((w15h >>> 8) | (w15l << 24)) ^ (w15h >>> 7) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 19) | (w12h << 13)) ^ ((w12l << 3) | (w12h >>> 29)) ^ ((w12l >>> 6) | (w12h << 26)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w12h >>> 19) | (w12l << 13)) ^ ((w12h << 3) | (w12l >>> 29)) ^ (w12h >>> 6) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xe003826f + w14l )|0;
            th = ( 0x6ca6351 + w14h + ((tl >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 31
            w15l = ( w15l + w8l )|0;
            w15h = ( w15h + w8h + ((w15l >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 1) | (w0h << 31)) ^ ((w0l >>> 8) | (w0h << 24)) ^ ((w0l >>> 7) | (w0h << 25)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w0h >>> 1) | (w0l << 31)) ^ ((w0h >>> 8) | (w0l << 24)) ^ (w0h >>> 7) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 19) | (w13h << 13)) ^ ((w13l << 3) | (w13h >>> 29)) ^ ((w13l >>> 6) | (w13h << 26)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w13h >>> 19) | (w13l << 13)) ^ ((w13h << 3) | (w13l >>> 29)) ^ (w13h >>> 6) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xa0e6e70 + w15l )|0;
            th = ( 0x14292967 + w15h + ((tl >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 32
            w0l = ( w0l + w9l )|0;
            w0h = ( w0h + w9h + ((w0l >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 1) | (w1h << 31)) ^ ((w1l >>> 8) | (w1h << 24)) ^ ((w1l >>> 7) | (w1h << 25)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w1h >>> 1) | (w1l << 31)) ^ ((w1h >>> 8) | (w1l << 24)) ^ (w1h >>> 7) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 19) | (w14h << 13)) ^ ((w14l << 3) | (w14h >>> 29)) ^ ((w14l >>> 6) | (w14h << 26)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w14h >>> 19) | (w14l << 13)) ^ ((w14h << 3) | (w14l >>> 29)) ^ (w14h >>> 6) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x46d22ffc + w0l )|0;
            th = ( 0x27b70a85 + w0h + ((tl >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 33
            w1l = ( w1l + w10l )|0;
            w1h = ( w1h + w10h + ((w1l >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 1) | (w2h << 31)) ^ ((w2l >>> 8) | (w2h << 24)) ^ ((w2l >>> 7) | (w2h << 25)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w2h >>> 1) | (w2l << 31)) ^ ((w2h >>> 8) | (w2l << 24)) ^ (w2h >>> 7) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 19) | (w15h << 13)) ^ ((w15l << 3) | (w15h >>> 29)) ^ ((w15l >>> 6) | (w15h << 26)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w15h >>> 19) | (w15l << 13)) ^ ((w15h << 3) | (w15l >>> 29)) ^ (w15h >>> 6) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x5c26c926 + w1l )|0;
            th = ( 0x2e1b2138 + w1h + ((tl >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 34
            w2l = ( w2l + w11l )|0;
            w2h = ( w2h + w11h + ((w2l >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 1) | (w3h << 31)) ^ ((w3l >>> 8) | (w3h << 24)) ^ ((w3l >>> 7) | (w3h << 25)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w3h >>> 1) | (w3l << 31)) ^ ((w3h >>> 8) | (w3l << 24)) ^ (w3h >>> 7) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 19) | (w0h << 13)) ^ ((w0l << 3) | (w0h >>> 29)) ^ ((w0l >>> 6) | (w0h << 26)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w0h >>> 19) | (w0l << 13)) ^ ((w0h << 3) | (w0l >>> 29)) ^ (w0h >>> 6) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x5ac42aed + w2l )|0;
            th = ( 0x4d2c6dfc + w2h + ((tl >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 35
            w3l = ( w3l + w12l )|0;
            w3h = ( w3h + w12h + ((w3l >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 1) | (w4h << 31)) ^ ((w4l >>> 8) | (w4h << 24)) ^ ((w4l >>> 7) | (w4h << 25)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w4h >>> 1) | (w4l << 31)) ^ ((w4h >>> 8) | (w4l << 24)) ^ (w4h >>> 7) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 19) | (w1h << 13)) ^ ((w1l << 3) | (w1h >>> 29)) ^ ((w1l >>> 6) | (w1h << 26)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w1h >>> 19) | (w1l << 13)) ^ ((w1h << 3) | (w1l >>> 29)) ^ (w1h >>> 6) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x9d95b3df + w3l )|0;
            th = ( 0x53380d13 + w3h + ((tl >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 36
            w4l = ( w4l + w13l )|0;
            w4h = ( w4h + w13h + ((w4l >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 1) | (w5h << 31)) ^ ((w5l >>> 8) | (w5h << 24)) ^ ((w5l >>> 7) | (w5h << 25)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w5h >>> 1) | (w5l << 31)) ^ ((w5h >>> 8) | (w5l << 24)) ^ (w5h >>> 7) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 19) | (w2h << 13)) ^ ((w2l << 3) | (w2h >>> 29)) ^ ((w2l >>> 6) | (w2h << 26)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w2h >>> 19) | (w2l << 13)) ^ ((w2h << 3) | (w2l >>> 29)) ^ (w2h >>> 6) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x8baf63de + w4l )|0;
            th = ( 0x650a7354 + w4h + ((tl >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 37
            w5l = ( w5l + w14l )|0;
            w5h = ( w5h + w14h + ((w5l >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 1) | (w6h << 31)) ^ ((w6l >>> 8) | (w6h << 24)) ^ ((w6l >>> 7) | (w6h << 25)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w6h >>> 1) | (w6l << 31)) ^ ((w6h >>> 8) | (w6l << 24)) ^ (w6h >>> 7) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 19) | (w3h << 13)) ^ ((w3l << 3) | (w3h >>> 29)) ^ ((w3l >>> 6) | (w3h << 26)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w3h >>> 19) | (w3l << 13)) ^ ((w3h << 3) | (w3l >>> 29)) ^ (w3h >>> 6) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x3c77b2a8 + w5l )|0;
            th = ( 0x766a0abb + w5h + ((tl >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 38
            w6l = ( w6l + w15l )|0;
            w6h = ( w6h + w15h + ((w6l >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 1) | (w7h << 31)) ^ ((w7l >>> 8) | (w7h << 24)) ^ ((w7l >>> 7) | (w7h << 25)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w7h >>> 1) | (w7l << 31)) ^ ((w7h >>> 8) | (w7l << 24)) ^ (w7h >>> 7) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 19) | (w4h << 13)) ^ ((w4l << 3) | (w4h >>> 29)) ^ ((w4l >>> 6) | (w4h << 26)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w4h >>> 19) | (w4l << 13)) ^ ((w4h << 3) | (w4l >>> 29)) ^ (w4h >>> 6) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x47edaee6 + w6l )|0;
            th = ( 0x81c2c92e + w6h + ((tl >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 39
            w7l = ( w7l + w0l )|0;
            w7h = ( w7h + w0h + ((w7l >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 1) | (w8h << 31)) ^ ((w8l >>> 8) | (w8h << 24)) ^ ((w8l >>> 7) | (w8h << 25)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w8h >>> 1) | (w8l << 31)) ^ ((w8h >>> 8) | (w8l << 24)) ^ (w8h >>> 7) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 19) | (w5h << 13)) ^ ((w5l << 3) | (w5h >>> 29)) ^ ((w5l >>> 6) | (w5h << 26)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w5h >>> 19) | (w5l << 13)) ^ ((w5h << 3) | (w5l >>> 29)) ^ (w5h >>> 6) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x1482353b + w7l )|0;
            th = ( 0x92722c85 + w7h + ((tl >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 40
            w8l = ( w8l + w1l )|0;
            w8h = ( w8h + w1h + ((w8l >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 1) | (w9h << 31)) ^ ((w9l >>> 8) | (w9h << 24)) ^ ((w9l >>> 7) | (w9h << 25)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w9h >>> 1) | (w9l << 31)) ^ ((w9h >>> 8) | (w9l << 24)) ^ (w9h >>> 7) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 19) | (w6h << 13)) ^ ((w6l << 3) | (w6h >>> 29)) ^ ((w6l >>> 6) | (w6h << 26)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w6h >>> 19) | (w6l << 13)) ^ ((w6h << 3) | (w6l >>> 29)) ^ (w6h >>> 6) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x4cf10364 + w8l )|0;
            th = ( 0xa2bfe8a1 + w8h + ((tl >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 41
            w9l = ( w9l + w2l )|0;
            w9h = ( w9h + w2h + ((w9l >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 1) | (w10h << 31)) ^ ((w10l >>> 8) | (w10h << 24)) ^ ((w10l >>> 7) | (w10h << 25)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w10h >>> 1) | (w10l << 31)) ^ ((w10h >>> 8) | (w10l << 24)) ^ (w10h >>> 7) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 19) | (w7h << 13)) ^ ((w7l << 3) | (w7h >>> 29)) ^ ((w7l >>> 6) | (w7h << 26)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w7h >>> 19) | (w7l << 13)) ^ ((w7h << 3) | (w7l >>> 29)) ^ (w7h >>> 6) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xbc423001 + w9l )|0;
            th = ( 0xa81a664b + w9h + ((tl >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 42
            w10l = ( w10l + w3l )|0;
            w10h = ( w10h + w3h + ((w10l >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 1) | (w11h << 31)) ^ ((w11l >>> 8) | (w11h << 24)) ^ ((w11l >>> 7) | (w11h << 25)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w11h >>> 1) | (w11l << 31)) ^ ((w11h >>> 8) | (w11l << 24)) ^ (w11h >>> 7) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 19) | (w8h << 13)) ^ ((w8l << 3) | (w8h >>> 29)) ^ ((w8l >>> 6) | (w8h << 26)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w8h >>> 19) | (w8l << 13)) ^ ((w8h << 3) | (w8l >>> 29)) ^ (w8h >>> 6) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xd0f89791 + w10l )|0;
            th = ( 0xc24b8b70 + w10h + ((tl >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 43
            w11l = ( w11l + w4l )|0;
            w11h = ( w11h + w4h + ((w11l >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 1) | (w12h << 31)) ^ ((w12l >>> 8) | (w12h << 24)) ^ ((w12l >>> 7) | (w12h << 25)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w12h >>> 1) | (w12l << 31)) ^ ((w12h >>> 8) | (w12l << 24)) ^ (w12h >>> 7) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 19) | (w9h << 13)) ^ ((w9l << 3) | (w9h >>> 29)) ^ ((w9l >>> 6) | (w9h << 26)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w9h >>> 19) | (w9l << 13)) ^ ((w9h << 3) | (w9l >>> 29)) ^ (w9h >>> 6) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x654be30 + w11l )|0;
            th = ( 0xc76c51a3 + w11h + ((tl >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 44
            w12l = ( w12l + w5l )|0;
            w12h = ( w12h + w5h + ((w12l >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 1) | (w13h << 31)) ^ ((w13l >>> 8) | (w13h << 24)) ^ ((w13l >>> 7) | (w13h << 25)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w13h >>> 1) | (w13l << 31)) ^ ((w13h >>> 8) | (w13l << 24)) ^ (w13h >>> 7) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 19) | (w10h << 13)) ^ ((w10l << 3) | (w10h >>> 29)) ^ ((w10l >>> 6) | (w10h << 26)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w10h >>> 19) | (w10l << 13)) ^ ((w10h << 3) | (w10l >>> 29)) ^ (w10h >>> 6) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xd6ef5218 + w12l )|0;
            th = ( 0xd192e819 + w12h + ((tl >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 45
            w13l = ( w13l + w6l )|0;
            w13h = ( w13h + w6h + ((w13l >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 1) | (w14h << 31)) ^ ((w14l >>> 8) | (w14h << 24)) ^ ((w14l >>> 7) | (w14h << 25)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w14h >>> 1) | (w14l << 31)) ^ ((w14h >>> 8) | (w14l << 24)) ^ (w14h >>> 7) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 19) | (w11h << 13)) ^ ((w11l << 3) | (w11h >>> 29)) ^ ((w11l >>> 6) | (w11h << 26)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w11h >>> 19) | (w11l << 13)) ^ ((w11h << 3) | (w11l >>> 29)) ^ (w11h >>> 6) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x5565a910 + w13l )|0;
            th = ( 0xd6990624 + w13h + ((tl >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 46
            w14l = ( w14l + w7l )|0;
            w14h = ( w14h + w7h + ((w14l >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 1) | (w15h << 31)) ^ ((w15l >>> 8) | (w15h << 24)) ^ ((w15l >>> 7) | (w15h << 25)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w15h >>> 1) | (w15l << 31)) ^ ((w15h >>> 8) | (w15l << 24)) ^ (w15h >>> 7) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 19) | (w12h << 13)) ^ ((w12l << 3) | (w12h >>> 29)) ^ ((w12l >>> 6) | (w12h << 26)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w12h >>> 19) | (w12l << 13)) ^ ((w12h << 3) | (w12l >>> 29)) ^ (w12h >>> 6) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x5771202a + w14l )|0;
            th = ( 0xf40e3585 + w14h + ((tl >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 47
            w15l = ( w15l + w8l )|0;
            w15h = ( w15h + w8h + ((w15l >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 1) | (w0h << 31)) ^ ((w0l >>> 8) | (w0h << 24)) ^ ((w0l >>> 7) | (w0h << 25)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w0h >>> 1) | (w0l << 31)) ^ ((w0h >>> 8) | (w0l << 24)) ^ (w0h >>> 7) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 19) | (w13h << 13)) ^ ((w13l << 3) | (w13h >>> 29)) ^ ((w13l >>> 6) | (w13h << 26)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w13h >>> 19) | (w13l << 13)) ^ ((w13h << 3) | (w13l >>> 29)) ^ (w13h >>> 6) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x32bbd1b8 + w15l )|0;
            th = ( 0x106aa070 + w15h + ((tl >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 48
            w0l = ( w0l + w9l )|0;
            w0h = ( w0h + w9h + ((w0l >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 1) | (w1h << 31)) ^ ((w1l >>> 8) | (w1h << 24)) ^ ((w1l >>> 7) | (w1h << 25)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w1h >>> 1) | (w1l << 31)) ^ ((w1h >>> 8) | (w1l << 24)) ^ (w1h >>> 7) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 19) | (w14h << 13)) ^ ((w14l << 3) | (w14h >>> 29)) ^ ((w14l >>> 6) | (w14h << 26)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w14h >>> 19) | (w14l << 13)) ^ ((w14h << 3) | (w14l >>> 29)) ^ (w14h >>> 6) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xb8d2d0c8 + w0l )|0;
            th = ( 0x19a4c116 + w0h + ((tl >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 49
            w1l = ( w1l + w10l )|0;
            w1h = ( w1h + w10h + ((w1l >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 1) | (w2h << 31)) ^ ((w2l >>> 8) | (w2h << 24)) ^ ((w2l >>> 7) | (w2h << 25)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w2h >>> 1) | (w2l << 31)) ^ ((w2h >>> 8) | (w2l << 24)) ^ (w2h >>> 7) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 19) | (w15h << 13)) ^ ((w15l << 3) | (w15h >>> 29)) ^ ((w15l >>> 6) | (w15h << 26)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w15h >>> 19) | (w15l << 13)) ^ ((w15h << 3) | (w15l >>> 29)) ^ (w15h >>> 6) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x5141ab53 + w1l )|0;
            th = ( 0x1e376c08 + w1h + ((tl >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 50
            w2l = ( w2l + w11l )|0;
            w2h = ( w2h + w11h + ((w2l >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 1) | (w3h << 31)) ^ ((w3l >>> 8) | (w3h << 24)) ^ ((w3l >>> 7) | (w3h << 25)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w3h >>> 1) | (w3l << 31)) ^ ((w3h >>> 8) | (w3l << 24)) ^ (w3h >>> 7) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 19) | (w0h << 13)) ^ ((w0l << 3) | (w0h >>> 29)) ^ ((w0l >>> 6) | (w0h << 26)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w0h >>> 19) | (w0l << 13)) ^ ((w0h << 3) | (w0l >>> 29)) ^ (w0h >>> 6) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xdf8eeb99 + w2l )|0;
            th = ( 0x2748774c + w2h + ((tl >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 51
            w3l = ( w3l + w12l )|0;
            w3h = ( w3h + w12h + ((w3l >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 1) | (w4h << 31)) ^ ((w4l >>> 8) | (w4h << 24)) ^ ((w4l >>> 7) | (w4h << 25)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w4h >>> 1) | (w4l << 31)) ^ ((w4h >>> 8) | (w4l << 24)) ^ (w4h >>> 7) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 19) | (w1h << 13)) ^ ((w1l << 3) | (w1h >>> 29)) ^ ((w1l >>> 6) | (w1h << 26)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w1h >>> 19) | (w1l << 13)) ^ ((w1h << 3) | (w1l >>> 29)) ^ (w1h >>> 6) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xe19b48a8 + w3l )|0;
            th = ( 0x34b0bcb5 + w3h + ((tl >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 52
            w4l = ( w4l + w13l )|0;
            w4h = ( w4h + w13h + ((w4l >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 1) | (w5h << 31)) ^ ((w5l >>> 8) | (w5h << 24)) ^ ((w5l >>> 7) | (w5h << 25)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w5h >>> 1) | (w5l << 31)) ^ ((w5h >>> 8) | (w5l << 24)) ^ (w5h >>> 7) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 19) | (w2h << 13)) ^ ((w2l << 3) | (w2h >>> 29)) ^ ((w2l >>> 6) | (w2h << 26)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w2h >>> 19) | (w2l << 13)) ^ ((w2h << 3) | (w2l >>> 29)) ^ (w2h >>> 6) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xc5c95a63 + w4l )|0;
            th = ( 0x391c0cb3 + w4h + ((tl >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 53
            w5l = ( w5l + w14l )|0;
            w5h = ( w5h + w14h + ((w5l >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 1) | (w6h << 31)) ^ ((w6l >>> 8) | (w6h << 24)) ^ ((w6l >>> 7) | (w6h << 25)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w6h >>> 1) | (w6l << 31)) ^ ((w6h >>> 8) | (w6l << 24)) ^ (w6h >>> 7) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 19) | (w3h << 13)) ^ ((w3l << 3) | (w3h >>> 29)) ^ ((w3l >>> 6) | (w3h << 26)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w3h >>> 19) | (w3l << 13)) ^ ((w3h << 3) | (w3l >>> 29)) ^ (w3h >>> 6) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xe3418acb + w5l )|0;
            th = ( 0x4ed8aa4a + w5h + ((tl >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 54
            w6l = ( w6l + w15l )|0;
            w6h = ( w6h + w15h + ((w6l >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 1) | (w7h << 31)) ^ ((w7l >>> 8) | (w7h << 24)) ^ ((w7l >>> 7) | (w7h << 25)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w7h >>> 1) | (w7l << 31)) ^ ((w7h >>> 8) | (w7l << 24)) ^ (w7h >>> 7) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 19) | (w4h << 13)) ^ ((w4l << 3) | (w4h >>> 29)) ^ ((w4l >>> 6) | (w4h << 26)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w4h >>> 19) | (w4l << 13)) ^ ((w4h << 3) | (w4l >>> 29)) ^ (w4h >>> 6) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x7763e373 + w6l )|0;
            th = ( 0x5b9cca4f + w6h + ((tl >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 55
            w7l = ( w7l + w0l )|0;
            w7h = ( w7h + w0h + ((w7l >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 1) | (w8h << 31)) ^ ((w8l >>> 8) | (w8h << 24)) ^ ((w8l >>> 7) | (w8h << 25)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w8h >>> 1) | (w8l << 31)) ^ ((w8h >>> 8) | (w8l << 24)) ^ (w8h >>> 7) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 19) | (w5h << 13)) ^ ((w5l << 3) | (w5h >>> 29)) ^ ((w5l >>> 6) | (w5h << 26)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w5h >>> 19) | (w5l << 13)) ^ ((w5h << 3) | (w5l >>> 29)) ^ (w5h >>> 6) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xd6b2b8a3 + w7l )|0;
            th = ( 0x682e6ff3 + w7h + ((tl >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 56
            w8l = ( w8l + w1l )|0;
            w8h = ( w8h + w1h + ((w8l >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 1) | (w9h << 31)) ^ ((w9l >>> 8) | (w9h << 24)) ^ ((w9l >>> 7) | (w9h << 25)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w9h >>> 1) | (w9l << 31)) ^ ((w9h >>> 8) | (w9l << 24)) ^ (w9h >>> 7) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 19) | (w6h << 13)) ^ ((w6l << 3) | (w6h >>> 29)) ^ ((w6l >>> 6) | (w6h << 26)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w6h >>> 19) | (w6l << 13)) ^ ((w6h << 3) | (w6l >>> 29)) ^ (w6h >>> 6) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x5defb2fc + w8l )|0;
            th = ( 0x748f82ee + w8h + ((tl >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 57
            w9l = ( w9l + w2l )|0;
            w9h = ( w9h + w2h + ((w9l >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 1) | (w10h << 31)) ^ ((w10l >>> 8) | (w10h << 24)) ^ ((w10l >>> 7) | (w10h << 25)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w10h >>> 1) | (w10l << 31)) ^ ((w10h >>> 8) | (w10l << 24)) ^ (w10h >>> 7) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 19) | (w7h << 13)) ^ ((w7l << 3) | (w7h >>> 29)) ^ ((w7l >>> 6) | (w7h << 26)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w7h >>> 19) | (w7l << 13)) ^ ((w7h << 3) | (w7l >>> 29)) ^ (w7h >>> 6) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x43172f60 + w9l )|0;
            th = ( 0x78a5636f + w9h + ((tl >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 58
            w10l = ( w10l + w3l )|0;
            w10h = ( w10h + w3h + ((w10l >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 1) | (w11h << 31)) ^ ((w11l >>> 8) | (w11h << 24)) ^ ((w11l >>> 7) | (w11h << 25)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w11h >>> 1) | (w11l << 31)) ^ ((w11h >>> 8) | (w11l << 24)) ^ (w11h >>> 7) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 19) | (w8h << 13)) ^ ((w8l << 3) | (w8h >>> 29)) ^ ((w8l >>> 6) | (w8h << 26)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w8h >>> 19) | (w8l << 13)) ^ ((w8h << 3) | (w8l >>> 29)) ^ (w8h >>> 6) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xa1f0ab72 + w10l )|0;
            th = ( 0x84c87814 + w10h + ((tl >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 59
            w11l = ( w11l + w4l )|0;
            w11h = ( w11h + w4h + ((w11l >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 1) | (w12h << 31)) ^ ((w12l >>> 8) | (w12h << 24)) ^ ((w12l >>> 7) | (w12h << 25)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w12h >>> 1) | (w12l << 31)) ^ ((w12h >>> 8) | (w12l << 24)) ^ (w12h >>> 7) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 19) | (w9h << 13)) ^ ((w9l << 3) | (w9h >>> 29)) ^ ((w9l >>> 6) | (w9h << 26)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w9h >>> 19) | (w9l << 13)) ^ ((w9h << 3) | (w9l >>> 29)) ^ (w9h >>> 6) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x1a6439ec + w11l )|0;
            th = ( 0x8cc70208 + w11h + ((tl >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 60
            w12l = ( w12l + w5l )|0;
            w12h = ( w12h + w5h + ((w12l >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 1) | (w13h << 31)) ^ ((w13l >>> 8) | (w13h << 24)) ^ ((w13l >>> 7) | (w13h << 25)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w13h >>> 1) | (w13l << 31)) ^ ((w13h >>> 8) | (w13l << 24)) ^ (w13h >>> 7) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 19) | (w10h << 13)) ^ ((w10l << 3) | (w10h >>> 29)) ^ ((w10l >>> 6) | (w10h << 26)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w10h >>> 19) | (w10l << 13)) ^ ((w10h << 3) | (w10l >>> 29)) ^ (w10h >>> 6) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x23631e28 + w12l )|0;
            th = ( 0x90befffa + w12h + ((tl >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 61
            w13l = ( w13l + w6l )|0;
            w13h = ( w13h + w6h + ((w13l >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 1) | (w14h << 31)) ^ ((w14l >>> 8) | (w14h << 24)) ^ ((w14l >>> 7) | (w14h << 25)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w14h >>> 1) | (w14l << 31)) ^ ((w14h >>> 8) | (w14l << 24)) ^ (w14h >>> 7) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 19) | (w11h << 13)) ^ ((w11l << 3) | (w11h >>> 29)) ^ ((w11l >>> 6) | (w11h << 26)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w11h >>> 19) | (w11l << 13)) ^ ((w11h << 3) | (w11l >>> 29)) ^ (w11h >>> 6) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xde82bde9 + w13l )|0;
            th = ( 0xa4506ceb + w13h + ((tl >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 62
            w14l = ( w14l + w7l )|0;
            w14h = ( w14h + w7h + ((w14l >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 1) | (w15h << 31)) ^ ((w15l >>> 8) | (w15h << 24)) ^ ((w15l >>> 7) | (w15h << 25)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w15h >>> 1) | (w15l << 31)) ^ ((w15h >>> 8) | (w15l << 24)) ^ (w15h >>> 7) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 19) | (w12h << 13)) ^ ((w12l << 3) | (w12h >>> 29)) ^ ((w12l >>> 6) | (w12h << 26)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w12h >>> 19) | (w12l << 13)) ^ ((w12h << 3) | (w12l >>> 29)) ^ (w12h >>> 6) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xb2c67915 + w14l )|0;
            th = ( 0xbef9a3f7 + w14h + ((tl >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 63
            w15l = ( w15l + w8l )|0;
            w15h = ( w15h + w8h + ((w15l >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 1) | (w0h << 31)) ^ ((w0l >>> 8) | (w0h << 24)) ^ ((w0l >>> 7) | (w0h << 25)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w0h >>> 1) | (w0l << 31)) ^ ((w0h >>> 8) | (w0l << 24)) ^ (w0h >>> 7) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 19) | (w13h << 13)) ^ ((w13l << 3) | (w13h >>> 29)) ^ ((w13l >>> 6) | (w13h << 26)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w13h >>> 19) | (w13l << 13)) ^ ((w13h << 3) | (w13l >>> 29)) ^ (w13h >>> 6) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xe372532b + w15l )|0;
            th = ( 0xc67178f2 + w15h + ((tl >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 64
            w0l = ( w0l + w9l )|0;
            w0h = ( w0h + w9h + ((w0l >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 1) | (w1h << 31)) ^ ((w1l >>> 8) | (w1h << 24)) ^ ((w1l >>> 7) | (w1h << 25)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w1h >>> 1) | (w1l << 31)) ^ ((w1h >>> 8) | (w1l << 24)) ^ (w1h >>> 7) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 19) | (w14h << 13)) ^ ((w14l << 3) | (w14h >>> 29)) ^ ((w14l >>> 6) | (w14h << 26)) )|0;
            w0l = ( w0l + xl)|0;
            w0h = ( w0h + ( ((w14h >>> 19) | (w14l << 13)) ^ ((w14h << 3) | (w14l >>> 29)) ^ (w14h >>> 6) ) + ((w0l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xea26619c + w0l )|0;
            th = ( 0xca273ece + w0h + ((tl >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 65
            w1l = ( w1l + w10l )|0;
            w1h = ( w1h + w10h + ((w1l >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 1) | (w2h << 31)) ^ ((w2l >>> 8) | (w2h << 24)) ^ ((w2l >>> 7) | (w2h << 25)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w2h >>> 1) | (w2l << 31)) ^ ((w2h >>> 8) | (w2l << 24)) ^ (w2h >>> 7) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 19) | (w15h << 13)) ^ ((w15l << 3) | (w15h >>> 29)) ^ ((w15l >>> 6) | (w15h << 26)) )|0;
            w1l = ( w1l + xl)|0;
            w1h = ( w1h + ( ((w15h >>> 19) | (w15l << 13)) ^ ((w15h << 3) | (w15l >>> 29)) ^ (w15h >>> 6) ) + ((w1l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x21c0c207 + w1l )|0;
            th = ( 0xd186b8c7 + w1h + ((tl >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 66
            w2l = ( w2l + w11l )|0;
            w2h = ( w2h + w11h + ((w2l >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 1) | (w3h << 31)) ^ ((w3l >>> 8) | (w3h << 24)) ^ ((w3l >>> 7) | (w3h << 25)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w3h >>> 1) | (w3l << 31)) ^ ((w3h >>> 8) | (w3l << 24)) ^ (w3h >>> 7) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 19) | (w0h << 13)) ^ ((w0l << 3) | (w0h >>> 29)) ^ ((w0l >>> 6) | (w0h << 26)) )|0;
            w2l = ( w2l + xl)|0;
            w2h = ( w2h + ( ((w0h >>> 19) | (w0l << 13)) ^ ((w0h << 3) | (w0l >>> 29)) ^ (w0h >>> 6) ) + ((w2l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xcde0eb1e + w2l )|0;
            th = ( 0xeada7dd6 + w2h + ((tl >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 67
            w3l = ( w3l + w12l )|0;
            w3h = ( w3h + w12h + ((w3l >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 1) | (w4h << 31)) ^ ((w4l >>> 8) | (w4h << 24)) ^ ((w4l >>> 7) | (w4h << 25)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w4h >>> 1) | (w4l << 31)) ^ ((w4h >>> 8) | (w4l << 24)) ^ (w4h >>> 7) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w1l >>> 19) | (w1h << 13)) ^ ((w1l << 3) | (w1h >>> 29)) ^ ((w1l >>> 6) | (w1h << 26)) )|0;
            w3l = ( w3l + xl)|0;
            w3h = ( w3h + ( ((w1h >>> 19) | (w1l << 13)) ^ ((w1h << 3) | (w1l >>> 29)) ^ (w1h >>> 6) ) + ((w3l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xee6ed178 + w3l )|0;
            th = ( 0xf57d4f7f + w3h + ((tl >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 68
            w4l = ( w4l + w13l )|0;
            w4h = ( w4h + w13h + ((w4l >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 1) | (w5h << 31)) ^ ((w5l >>> 8) | (w5h << 24)) ^ ((w5l >>> 7) | (w5h << 25)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w5h >>> 1) | (w5l << 31)) ^ ((w5h >>> 8) | (w5l << 24)) ^ (w5h >>> 7) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w2l >>> 19) | (w2h << 13)) ^ ((w2l << 3) | (w2h >>> 29)) ^ ((w2l >>> 6) | (w2h << 26)) )|0;
            w4l = ( w4l + xl)|0;
            w4h = ( w4h + ( ((w2h >>> 19) | (w2l << 13)) ^ ((w2h << 3) | (w2l >>> 29)) ^ (w2h >>> 6) ) + ((w4l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x72176fba + w4l )|0;
            th = ( 0x6f067aa + w4h + ((tl >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 69
            w5l = ( w5l + w14l )|0;
            w5h = ( w5h + w14h + ((w5l >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 1) | (w6h << 31)) ^ ((w6l >>> 8) | (w6h << 24)) ^ ((w6l >>> 7) | (w6h << 25)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w6h >>> 1) | (w6l << 31)) ^ ((w6h >>> 8) | (w6l << 24)) ^ (w6h >>> 7) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w3l >>> 19) | (w3h << 13)) ^ ((w3l << 3) | (w3h >>> 29)) ^ ((w3l >>> 6) | (w3h << 26)) )|0;
            w5l = ( w5l + xl)|0;
            w5h = ( w5h + ( ((w3h >>> 19) | (w3l << 13)) ^ ((w3h << 3) | (w3l >>> 29)) ^ (w3h >>> 6) ) + ((w5l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xa2c898a6 + w5l )|0;
            th = ( 0xa637dc5 + w5h + ((tl >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 70
            w6l = ( w6l + w15l )|0;
            w6h = ( w6h + w15h + ((w6l >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 1) | (w7h << 31)) ^ ((w7l >>> 8) | (w7h << 24)) ^ ((w7l >>> 7) | (w7h << 25)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w7h >>> 1) | (w7l << 31)) ^ ((w7h >>> 8) | (w7l << 24)) ^ (w7h >>> 7) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w4l >>> 19) | (w4h << 13)) ^ ((w4l << 3) | (w4h >>> 29)) ^ ((w4l >>> 6) | (w4h << 26)) )|0;
            w6l = ( w6l + xl)|0;
            w6h = ( w6h + ( ((w4h >>> 19) | (w4l << 13)) ^ ((w4h << 3) | (w4l >>> 29)) ^ (w4h >>> 6) ) + ((w6l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xbef90dae + w6l )|0;
            th = ( 0x113f9804 + w6h + ((tl >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 71
            w7l = ( w7l + w0l )|0;
            w7h = ( w7h + w0h + ((w7l >>> 0) < (w0l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 1) | (w8h << 31)) ^ ((w8l >>> 8) | (w8h << 24)) ^ ((w8l >>> 7) | (w8h << 25)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w8h >>> 1) | (w8l << 31)) ^ ((w8h >>> 8) | (w8l << 24)) ^ (w8h >>> 7) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w5l >>> 19) | (w5h << 13)) ^ ((w5l << 3) | (w5h >>> 29)) ^ ((w5l >>> 6) | (w5h << 26)) )|0;
            w7l = ( w7l + xl)|0;
            w7h = ( w7h + ( ((w5h >>> 19) | (w5l << 13)) ^ ((w5h << 3) | (w5l >>> 29)) ^ (w5h >>> 6) ) + ((w7l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x131c471b + w7l )|0;
            th = ( 0x1b710b35 + w7h + ((tl >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 72
            w8l = ( w8l + w1l )|0;
            w8h = ( w8h + w1h + ((w8l >>> 0) < (w1l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 1) | (w9h << 31)) ^ ((w9l >>> 8) | (w9h << 24)) ^ ((w9l >>> 7) | (w9h << 25)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w9h >>> 1) | (w9l << 31)) ^ ((w9h >>> 8) | (w9l << 24)) ^ (w9h >>> 7) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w6l >>> 19) | (w6h << 13)) ^ ((w6l << 3) | (w6h >>> 29)) ^ ((w6l >>> 6) | (w6h << 26)) )|0;
            w8l = ( w8l + xl)|0;
            w8h = ( w8h + ( ((w6h >>> 19) | (w6l << 13)) ^ ((w6h << 3) | (w6l >>> 29)) ^ (w6h >>> 6) ) + ((w8l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x23047d84 + w8l )|0;
            th = ( 0x28db77f5 + w8h + ((tl >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 73
            w9l = ( w9l + w2l )|0;
            w9h = ( w9h + w2h + ((w9l >>> 0) < (w2l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 1) | (w10h << 31)) ^ ((w10l >>> 8) | (w10h << 24)) ^ ((w10l >>> 7) | (w10h << 25)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w10h >>> 1) | (w10l << 31)) ^ ((w10h >>> 8) | (w10l << 24)) ^ (w10h >>> 7) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w7l >>> 19) | (w7h << 13)) ^ ((w7l << 3) | (w7h >>> 29)) ^ ((w7l >>> 6) | (w7h << 26)) )|0;
            w9l = ( w9l + xl)|0;
            w9h = ( w9h + ( ((w7h >>> 19) | (w7l << 13)) ^ ((w7h << 3) | (w7l >>> 29)) ^ (w7h >>> 6) ) + ((w9l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x40c72493 + w9l )|0;
            th = ( 0x32caab7b + w9h + ((tl >>> 0) < (w9l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 74
            w10l = ( w10l + w3l )|0;
            w10h = ( w10h + w3h + ((w10l >>> 0) < (w3l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 1) | (w11h << 31)) ^ ((w11l >>> 8) | (w11h << 24)) ^ ((w11l >>> 7) | (w11h << 25)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w11h >>> 1) | (w11l << 31)) ^ ((w11h >>> 8) | (w11l << 24)) ^ (w11h >>> 7) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w8l >>> 19) | (w8h << 13)) ^ ((w8l << 3) | (w8h >>> 29)) ^ ((w8l >>> 6) | (w8h << 26)) )|0;
            w10l = ( w10l + xl)|0;
            w10h = ( w10h + ( ((w8h >>> 19) | (w8l << 13)) ^ ((w8h << 3) | (w8l >>> 29)) ^ (w8h >>> 6) ) + ((w10l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x15c9bebc + w10l )|0;
            th = ( 0x3c9ebe0a + w10h + ((tl >>> 0) < (w10l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 75
            w11l = ( w11l + w4l )|0;
            w11h = ( w11h + w4h + ((w11l >>> 0) < (w4l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 1) | (w12h << 31)) ^ ((w12l >>> 8) | (w12h << 24)) ^ ((w12l >>> 7) | (w12h << 25)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w12h >>> 1) | (w12l << 31)) ^ ((w12h >>> 8) | (w12l << 24)) ^ (w12h >>> 7) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w9l >>> 19) | (w9h << 13)) ^ ((w9l << 3) | (w9h >>> 29)) ^ ((w9l >>> 6) | (w9h << 26)) )|0;
            w11l = ( w11l + xl)|0;
            w11h = ( w11h + ( ((w9h >>> 19) | (w9l << 13)) ^ ((w9h << 3) | (w9l >>> 29)) ^ (w9h >>> 6) ) + ((w11l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x9c100d4c + w11l )|0;
            th = ( 0x431d67c4 + w11h + ((tl >>> 0) < (w11l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 76
            w12l = ( w12l + w5l )|0;
            w12h = ( w12h + w5h + ((w12l >>> 0) < (w5l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 1) | (w13h << 31)) ^ ((w13l >>> 8) | (w13h << 24)) ^ ((w13l >>> 7) | (w13h << 25)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w13h >>> 1) | (w13l << 31)) ^ ((w13h >>> 8) | (w13l << 24)) ^ (w13h >>> 7) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w10l >>> 19) | (w10h << 13)) ^ ((w10l << 3) | (w10h >>> 29)) ^ ((w10l >>> 6) | (w10h << 26)) )|0;
            w12l = ( w12l + xl)|0;
            w12h = ( w12h + ( ((w10h >>> 19) | (w10l << 13)) ^ ((w10h << 3) | (w10l >>> 29)) ^ (w10h >>> 6) ) + ((w12l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xcb3e42b6 + w12l )|0;
            th = ( 0x4cc5d4be + w12h + ((tl >>> 0) < (w12l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 77
            w13l = ( w13l + w6l )|0;
            w13h = ( w13h + w6h + ((w13l >>> 0) < (w6l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w14l >>> 1) | (w14h << 31)) ^ ((w14l >>> 8) | (w14h << 24)) ^ ((w14l >>> 7) | (w14h << 25)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w14h >>> 1) | (w14l << 31)) ^ ((w14h >>> 8) | (w14l << 24)) ^ (w14h >>> 7) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w11l >>> 19) | (w11h << 13)) ^ ((w11l << 3) | (w11h >>> 29)) ^ ((w11l >>> 6) | (w11h << 26)) )|0;
            w13l = ( w13l + xl)|0;
            w13h = ( w13h + ( ((w11h >>> 19) | (w11l << 13)) ^ ((w11h << 3) | (w11l >>> 29)) ^ (w11h >>> 6) ) + ((w13l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0xfc657e2a + w13l )|0;
            th = ( 0x597f299c + w13h + ((tl >>> 0) < (w13l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 78
            w14l = ( w14l + w7l )|0;
            w14h = ( w14h + w7h + ((w14l >>> 0) < (w7l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w15l >>> 1) | (w15h << 31)) ^ ((w15l >>> 8) | (w15h << 24)) ^ ((w15l >>> 7) | (w15h << 25)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w15h >>> 1) | (w15l << 31)) ^ ((w15h >>> 8) | (w15l << 24)) ^ (w15h >>> 7) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w12l >>> 19) | (w12h << 13)) ^ ((w12l << 3) | (w12h >>> 29)) ^ ((w12l >>> 6) | (w12h << 26)) )|0;
            w14l = ( w14l + xl)|0;
            w14h = ( w14h + ( ((w12h >>> 19) | (w12l << 13)) ^ ((w12h << 3) | (w12l >>> 29)) ^ (w12h >>> 6) ) + ((w14l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x3ad6faec + w14l )|0;
            th = ( 0x5fcb6fab + w14h + ((tl >>> 0) < (w14l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            // 79
            w15l = ( w15l + w8l )|0;
            w15h = ( w15h + w8h + ((w15l >>> 0) < (w8l >>> 0) ? 1 : 0) )|0;
            xl = ( ((w0l >>> 1) | (w0h << 31)) ^ ((w0l >>> 8) | (w0h << 24)) ^ ((w0l >>> 7) | (w0h << 25)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w0h >>> 1) | (w0l << 31)) ^ ((w0h >>> 8) | (w0l << 24)) ^ (w0h >>> 7) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ((w13l >>> 19) | (w13h << 13)) ^ ((w13l << 3) | (w13h >>> 29)) ^ ((w13l >>> 6) | (w13h << 26)) )|0;
            w15l = ( w15l + xl)|0;
            w15h = ( w15h + ( ((w13h >>> 19) | (w13l << 13)) ^ ((w13h << 3) | (w13l >>> 29)) ^ (w13h >>> 6) ) + ((w15l >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            tl = ( 0x4a475817 + w15l )|0;
            th = ( 0x6c44198c + w15h + ((tl >>> 0) < (w15l >>> 0) ? 1 : 0) )|0;
            tl = ( tl + hl )|0;
            th = ( th + hh + ((tl >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
            xl = ( ((el >>> 14) | (eh << 18)) ^ ((el >>> 18) | (eh << 14)) ^ ((el << 23) | (eh >>> 9)) )|0;
            tl = ( tl + xl )|0;
            th = ( th + (((eh >>> 14) | (el << 18)) ^ ((eh >>> 18) | (el << 14)) ^ ((eh << 23) | (el >>> 9))) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            xl = ( ( gl ^ el & (fl^gl) ) )|0;
            tl = ( tl + xl )|0;
            th = ( th + ( gh ^ eh & (fh^gh) ) + ((tl >>> 0) < (xl >>> 0) ? 1 : 0) )|0;
            hl = gl; hh = gh;
            gl = fl; gh = fh;
            fl = el; fh = eh;
            el = ( dl + tl )|0; eh = ( dh + th + ((el >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            dl = cl; dh = ch;
            cl = bl; ch = bh;
            bl = al; bh = ah;
            al = ( tl + ( (bl & cl) ^ ( dl & (bl ^ cl) ) ) )|0;
            ah = ( th + ( (bh & ch) ^ ( dh & (bh ^ ch) ) ) + ((al >>> 0) < (tl >>> 0) ? 1 : 0) )|0;
            xl = ( ((bl >>> 28) | (bh << 4)) ^ ((bl << 30) | (bh >>> 2)) ^ ((bl << 25) | (bh >>> 7)) )|0;
            al = ( al + xl )|0;
            ah = ( ah + (((bh >>> 28) | (bl << 4)) ^ ((bh << 30) | (bl >>> 2)) ^ ((bh << 25) | (bl >>> 7))) + ((al >>> 0) < (xl >>> 0) ? 1 : 0) )|0;

            H0l = ( H0l + al )|0;
            H0h = ( H0h + ah + ((H0l >>> 0) < (al >>> 0) ? 1 : 0) )|0;
            H1l = ( H1l + bl )|0;
            H1h = ( H1h + bh + ((H1l >>> 0) < (bl >>> 0) ? 1 : 0) )|0;
            H2l = ( H2l + cl )|0;
            H2h = ( H2h + ch + ((H2l >>> 0) < (cl >>> 0) ? 1 : 0) )|0;
            H3l = ( H3l + dl )|0;
            H3h = ( H3h + dh + ((H3l >>> 0) < (dl >>> 0) ? 1 : 0) )|0;
            H4l = ( H4l + el )|0;
            H4h = ( H4h + eh + ((H4l >>> 0) < (el >>> 0) ? 1 : 0) )|0;
            H5l = ( H5l + fl )|0;
            H5h = ( H5h + fh + ((H5l >>> 0) < (fl >>> 0) ? 1 : 0) )|0;
            H6l = ( H6l + gl )|0;
            H6h = ( H6h + gh + ((H6l >>> 0) < (gl >>> 0) ? 1 : 0) )|0;
            H7l = ( H7l + hl )|0;
            H7h = ( H7h + hh + ((H7l >>> 0) < (hl >>> 0) ? 1 : 0) )|0;
        }

        function _core_heap ( offset ) {
            offset = offset|0;

            _core(
                HEAP[offset|0]<<24 | HEAP[offset|1]<<16 | HEAP[offset|2]<<8 | HEAP[offset|3],
                HEAP[offset|4]<<24 | HEAP[offset|5]<<16 | HEAP[offset|6]<<8 | HEAP[offset|7],
                HEAP[offset|8]<<24 | HEAP[offset|9]<<16 | HEAP[offset|10]<<8 | HEAP[offset|11],
                HEAP[offset|12]<<24 | HEAP[offset|13]<<16 | HEAP[offset|14]<<8 | HEAP[offset|15],
                HEAP[offset|16]<<24 | HEAP[offset|17]<<16 | HEAP[offset|18]<<8 | HEAP[offset|19],
                HEAP[offset|20]<<24 | HEAP[offset|21]<<16 | HEAP[offset|22]<<8 | HEAP[offset|23],
                HEAP[offset|24]<<24 | HEAP[offset|25]<<16 | HEAP[offset|26]<<8 | HEAP[offset|27],
                HEAP[offset|28]<<24 | HEAP[offset|29]<<16 | HEAP[offset|30]<<8 | HEAP[offset|31],
                HEAP[offset|32]<<24 | HEAP[offset|33]<<16 | HEAP[offset|34]<<8 | HEAP[offset|35],
                HEAP[offset|36]<<24 | HEAP[offset|37]<<16 | HEAP[offset|38]<<8 | HEAP[offset|39],
                HEAP[offset|40]<<24 | HEAP[offset|41]<<16 | HEAP[offset|42]<<8 | HEAP[offset|43],
                HEAP[offset|44]<<24 | HEAP[offset|45]<<16 | HEAP[offset|46]<<8 | HEAP[offset|47],
                HEAP[offset|48]<<24 | HEAP[offset|49]<<16 | HEAP[offset|50]<<8 | HEAP[offset|51],
                HEAP[offset|52]<<24 | HEAP[offset|53]<<16 | HEAP[offset|54]<<8 | HEAP[offset|55],
                HEAP[offset|56]<<24 | HEAP[offset|57]<<16 | HEAP[offset|58]<<8 | HEAP[offset|59],
                HEAP[offset|60]<<24 | HEAP[offset|61]<<16 | HEAP[offset|62]<<8 | HEAP[offset|63],
                HEAP[offset|64]<<24 | HEAP[offset|65]<<16 | HEAP[offset|66]<<8 | HEAP[offset|67],
                HEAP[offset|68]<<24 | HEAP[offset|69]<<16 | HEAP[offset|70]<<8 | HEAP[offset|71],
                HEAP[offset|72]<<24 | HEAP[offset|73]<<16 | HEAP[offset|74]<<8 | HEAP[offset|75],
                HEAP[offset|76]<<24 | HEAP[offset|77]<<16 | HEAP[offset|78]<<8 | HEAP[offset|79],
                HEAP[offset|80]<<24 | HEAP[offset|81]<<16 | HEAP[offset|82]<<8 | HEAP[offset|83],
                HEAP[offset|84]<<24 | HEAP[offset|85]<<16 | HEAP[offset|86]<<8 | HEAP[offset|87],
                HEAP[offset|88]<<24 | HEAP[offset|89]<<16 | HEAP[offset|90]<<8 | HEAP[offset|91],
                HEAP[offset|92]<<24 | HEAP[offset|93]<<16 | HEAP[offset|94]<<8 | HEAP[offset|95],
                HEAP[offset|96]<<24 | HEAP[offset|97]<<16 | HEAP[offset|98]<<8 | HEAP[offset|99],
                HEAP[offset|100]<<24 | HEAP[offset|101]<<16 | HEAP[offset|102]<<8 | HEAP[offset|103],
                HEAP[offset|104]<<24 | HEAP[offset|105]<<16 | HEAP[offset|106]<<8 | HEAP[offset|107],
                HEAP[offset|108]<<24 | HEAP[offset|109]<<16 | HEAP[offset|110]<<8 | HEAP[offset|111],
                HEAP[offset|112]<<24 | HEAP[offset|113]<<16 | HEAP[offset|114]<<8 | HEAP[offset|115],
                HEAP[offset|116]<<24 | HEAP[offset|117]<<16 | HEAP[offset|118]<<8 | HEAP[offset|119],
                HEAP[offset|120]<<24 | HEAP[offset|121]<<16 | HEAP[offset|122]<<8 | HEAP[offset|123],
                HEAP[offset|124]<<24 | HEAP[offset|125]<<16 | HEAP[offset|126]<<8 | HEAP[offset|127]
            );
        }

        // offset — multiple of 32
        function _state_to_heap ( output ) {
            output = output|0;

            HEAP[output|0] = H0h>>>24;
            HEAP[output|1] = H0h>>>16&255;
            HEAP[output|2] = H0h>>>8&255;
            HEAP[output|3] = H0h&255;
            HEAP[output|4] = H0l>>>24;
            HEAP[output|5] = H0l>>>16&255;
            HEAP[output|6] = H0l>>>8&255;
            HEAP[output|7] = H0l&255;
            HEAP[output|8] = H1h>>>24;
            HEAP[output|9] = H1h>>>16&255;
            HEAP[output|10] = H1h>>>8&255;
            HEAP[output|11] = H1h&255;
            HEAP[output|12] = H1l>>>24;
            HEAP[output|13] = H1l>>>16&255;
            HEAP[output|14] = H1l>>>8&255;
            HEAP[output|15] = H1l&255;
            HEAP[output|16] = H2h>>>24;
            HEAP[output|17] = H2h>>>16&255;
            HEAP[output|18] = H2h>>>8&255;
            HEAP[output|19] = H2h&255;
            HEAP[output|20] = H2l>>>24;
            HEAP[output|21] = H2l>>>16&255;
            HEAP[output|22] = H2l>>>8&255;
            HEAP[output|23] = H2l&255;
            HEAP[output|24] = H3h>>>24;
            HEAP[output|25] = H3h>>>16&255;
            HEAP[output|26] = H3h>>>8&255;
            HEAP[output|27] = H3h&255;
            HEAP[output|28] = H3l>>>24;
            HEAP[output|29] = H3l>>>16&255;
            HEAP[output|30] = H3l>>>8&255;
            HEAP[output|31] = H3l&255;
            HEAP[output|32] = H4h>>>24;
            HEAP[output|33] = H4h>>>16&255;
            HEAP[output|34] = H4h>>>8&255;
            HEAP[output|35] = H4h&255;
            HEAP[output|36] = H4l>>>24;
            HEAP[output|37] = H4l>>>16&255;
            HEAP[output|38] = H4l>>>8&255;
            HEAP[output|39] = H4l&255;
            HEAP[output|40] = H5h>>>24;
            HEAP[output|41] = H5h>>>16&255;
            HEAP[output|42] = H5h>>>8&255;
            HEAP[output|43] = H5h&255;
            HEAP[output|44] = H5l>>>24;
            HEAP[output|45] = H5l>>>16&255;
            HEAP[output|46] = H5l>>>8&255;
            HEAP[output|47] = H5l&255;
            HEAP[output|48] = H6h>>>24;
            HEAP[output|49] = H6h>>>16&255;
            HEAP[output|50] = H6h>>>8&255;
            HEAP[output|51] = H6h&255;
            HEAP[output|52] = H6l>>>24;
            HEAP[output|53] = H6l>>>16&255;
            HEAP[output|54] = H6l>>>8&255;
            HEAP[output|55] = H6l&255;
            HEAP[output|56] = H7h>>>24;
            HEAP[output|57] = H7h>>>16&255;
            HEAP[output|58] = H7h>>>8&255;
            HEAP[output|59] = H7h&255;
            HEAP[output|60] = H7l>>>24;
            HEAP[output|61] = H7l>>>16&255;
            HEAP[output|62] = H7l>>>8&255;
            HEAP[output|63] = H7l&255;
        }

        function reset () {
            H0h = 0x6a09e667;
            H0l = 0xf3bcc908;
            H1h = 0xbb67ae85;
            H1l = 0x84caa73b;
            H2h = 0x3c6ef372;
            H2l = 0xfe94f82b;
            H3h = 0xa54ff53a;
            H3l = 0x5f1d36f1;
            H4h = 0x510e527f;
            H4l = 0xade682d1;
            H5h = 0x9b05688c;
            H5l = 0x2b3e6c1f;
            H6h = 0x1f83d9ab;
            H6l = 0xfb41bd6b;
            H7h = 0x5be0cd19;
            H7l = 0x137e2179;

            TOTAL0 = TOTAL1 = 0;
        }

        function init ( h0h, h0l, h1h, h1l, h2h, h2l, h3h, h3l, h4h, h4l, h5h, h5l, h6h, h6l, h7h, h7l, total0, total1 ) {
            h0h = h0h|0;
            h0l = h0l|0;
            h1h = h1h|0;
            h1l = h1l|0;
            h2h = h2h|0;
            h2l = h2l|0;
            h3h = h3h|0;
            h3l = h3l|0;
            h4h = h4h|0;
            h4l = h4l|0;
            h5h = h5h|0;
            h5l = h5l|0;
            h6h = h6h|0;
            h6l = h6l|0;
            h7h = h7h|0;
            h7l = h7l|0;
            total0 = total0|0;
            total1 = total1|0;

            H0h = h0h;
            H0l = h0l;
            H1h = h1h;
            H1l = h1l;
            H2h = h2h;
            H2l = h2l;
            H3h = h3h;
            H3l = h3l;
            H4h = h4h;
            H4l = h4l;
            H5h = h5h;
            H5l = h5l;
            H6h = h6h;
            H6l = h6l;
            H7h = h7h;
            H7l = h7l;
            TOTAL0 = total0;
            TOTAL1 = total1;
        }

        // offset — multiple of 128
        function process ( offset, length ) {
            offset = offset|0;
            length = length|0;

            var hashed = 0;

            if ( offset & 127 )
                return -1;

            while ( (length|0) >= 128 ) {
                _core_heap(offset);

                offset = ( offset + 128 )|0;
                length = ( length - 128 )|0;

                hashed = ( hashed + 128 )|0;
            }

            TOTAL0 = ( TOTAL0 + hashed )|0;
            if ( TOTAL0>>>0 < hashed>>>0 ) TOTAL1 = ( TOTAL1 + 1 )|0;

            return hashed|0;
        }

        // offset — multiple of 128
        // output — multiple of 64
        function finish ( offset, length, output ) {
            offset = offset|0;
            length = length|0;
            output = output|0;

            var hashed = 0,
                i = 0;

            if ( offset & 127 )
                return -1;

            if ( ~output )
                if ( output & 63 )
                    return -1;

            if ( (length|0) >= 128 ) {
                hashed = process( offset, length )|0;
                if ( (hashed|0) == -1 )
                    return -1;

                offset = ( offset + hashed )|0;
                length = ( length - hashed )|0;
            }

            hashed = ( hashed + length )|0;
            TOTAL0 = ( TOTAL0 + length )|0;
            if ( TOTAL0>>>0 < length>>>0 ) TOTAL1 = ( TOTAL1 + 1 )|0;

            HEAP[offset|length] = 0x80;

            if ( (length|0) >= 112 ) {
                for ( i = (length+1)|0; (i|0) < 128; i = (i+1)|0 )
                    HEAP[offset|i] = 0x00;

                _core_heap(offset);

                length = 0;

                HEAP[offset|0] = 0;
            }

            for ( i = (length+1)|0; (i|0) < 123; i = (i+1)|0 )
                HEAP[offset|i] = 0;

            HEAP[offset|120] = TOTAL1>>>21&255;
            HEAP[offset|121] = TOTAL1>>>13&255;
            HEAP[offset|122] = TOTAL1>>>5&255;
            HEAP[offset|123] = TOTAL1<<3&255 | TOTAL0>>>29;
            HEAP[offset|124] = TOTAL0>>>21&255;
            HEAP[offset|125] = TOTAL0>>>13&255;
            HEAP[offset|126] = TOTAL0>>>5&255;
            HEAP[offset|127] = TOTAL0<<3&255;
            _core_heap(offset);

            if ( ~output )
                _state_to_heap(output);

            return hashed|0;
        }

        function hmac_reset () {
            H0h = I0h;
            H0l = I0l;
            H1h = I1h;
            H1l = I1l;
            H2h = I2h;
            H2l = I2l;
            H3h = I3h;
            H3l = I3l;
            H4h = I4h;
            H4l = I4l;
            H5h = I5h;
            H5l = I5l;
            H6h = I6h;
            H6l = I6l;
            H7h = I7h;
            H7l = I7l;
            TOTAL0 = 128;
            TOTAL1 = 0;
        }

        function _hmac_opad () {
            H0h = O0h;
            H0l = O0l;
            H1h = O1h;
            H1l = O1l;
            H2h = O2h;
            H2l = O2l;
            H3h = O3h;
            H3l = O3l;
            H4h = O4h;
            H4l = O4l;
            H5h = O5h;
            H5l = O5l;
            H6h = O6h;
            H6l = O6l;
            H7h = O7h;
            H7l = O7l;
            TOTAL0 = 128;
            TOTAL1 = 0;
        }

        function hmac_init ( p0h, p0l, p1h, p1l, p2h, p2l, p3h, p3l, p4h, p4l, p5h, p5l, p6h, p6l, p7h, p7l, p8h, p8l, p9h, p9l, p10h, p10l, p11h, p11l, p12h, p12l, p13h, p13l, p14h, p14l, p15h, p15l ) {
            p0h = p0h|0;
            p0l = p0l|0;
            p1h = p1h|0;
            p1l = p1l|0;
            p2h = p2h|0;
            p2l = p2l|0;
            p3h = p3h|0;
            p3l = p3l|0;
            p4h = p4h|0;
            p4l = p4l|0;
            p5h = p5h|0;
            p5l = p5l|0;
            p6h = p6h|0;
            p6l = p6l|0;
            p7h = p7h|0;
            p7l = p7l|0;
            p8h = p8h|0;
            p8l = p8l|0;
            p9h = p9h|0;
            p9l = p9l|0;
            p10h = p10h|0;
            p10l = p10l|0;
            p11h = p11h|0;
            p11l = p11l|0;
            p12h = p12h|0;
            p12l = p12l|0;
            p13h = p13h|0;
            p13l = p13l|0;
            p14h = p14h|0;
            p14l = p14l|0;
            p15h = p15h|0;
            p15l = p15l|0;

            // opad
            reset();
            _core(
                p0h ^ 0x5c5c5c5c,
                p0l ^ 0x5c5c5c5c,
                p1h ^ 0x5c5c5c5c,
                p1l ^ 0x5c5c5c5c,
                p2h ^ 0x5c5c5c5c,
                p2l ^ 0x5c5c5c5c,
                p3h ^ 0x5c5c5c5c,
                p3l ^ 0x5c5c5c5c,
                p4h ^ 0x5c5c5c5c,
                p4l ^ 0x5c5c5c5c,
                p5h ^ 0x5c5c5c5c,
                p5l ^ 0x5c5c5c5c,
                p6h ^ 0x5c5c5c5c,
                p6l ^ 0x5c5c5c5c,
                p7h ^ 0x5c5c5c5c,
                p7l ^ 0x5c5c5c5c,
                p8h ^ 0x5c5c5c5c,
                p8l ^ 0x5c5c5c5c,
                p9h ^ 0x5c5c5c5c,
                p9l ^ 0x5c5c5c5c,
                p10h ^ 0x5c5c5c5c,
                p10l ^ 0x5c5c5c5c,
                p11h ^ 0x5c5c5c5c,
                p11l ^ 0x5c5c5c5c,
                p12h ^ 0x5c5c5c5c,
                p12l ^ 0x5c5c5c5c,
                p13h ^ 0x5c5c5c5c,
                p13l ^ 0x5c5c5c5c,
                p14h ^ 0x5c5c5c5c,
                p14l ^ 0x5c5c5c5c,
                p15h ^ 0x5c5c5c5c,
                p15l ^ 0x5c5c5c5c
            );
            O0h = H0h;
            O0l = H0l;
            O1h = H1h;
            O1l = H1l;
            O2h = H2h;
            O2l = H2l;
            O3h = H3h;
            O3l = H3l;
            O4h = H4h;
            O4l = H4l;
            O5h = H5h;
            O5l = H5l;
            O6h = H6h;
            O6l = H6l;
            O7h = H7h;
            O7l = H7l;

            // ipad
            reset();
            _core(
               p0h ^ 0x36363636,
               p0l ^ 0x36363636,
               p1h ^ 0x36363636,
               p1l ^ 0x36363636,
               p2h ^ 0x36363636,
               p2l ^ 0x36363636,
               p3h ^ 0x36363636,
               p3l ^ 0x36363636,
               p4h ^ 0x36363636,
               p4l ^ 0x36363636,
               p5h ^ 0x36363636,
               p5l ^ 0x36363636,
               p6h ^ 0x36363636,
               p6l ^ 0x36363636,
               p7h ^ 0x36363636,
               p7l ^ 0x36363636,
               p8h ^ 0x36363636,
               p8l ^ 0x36363636,
               p9h ^ 0x36363636,
               p9l ^ 0x36363636,
               p10h ^ 0x36363636,
               p10l ^ 0x36363636,
               p11h ^ 0x36363636,
               p11l ^ 0x36363636,
               p12h ^ 0x36363636,
               p12l ^ 0x36363636,
               p13h ^ 0x36363636,
               p13l ^ 0x36363636,
               p14h ^ 0x36363636,
               p14l ^ 0x36363636,
               p15h ^ 0x36363636,
               p15l ^ 0x36363636
            );
            I0h = H0h;
            I0l = H0l;
            I1h = H1h;
            I1l = H1l;
            I2h = H2h;
            I2l = H2l;
            I3h = H3h;
            I3l = H3l;
            I4h = H4h;
            I4l = H4l;
            I5h = H5h;
            I5l = H5l;
            I6h = H6h;
            I6l = H6l;
            I7h = H7h;
            I7l = H7l;

            TOTAL0 = 128;
            TOTAL1 = 0;
        }

        // offset — multiple of 128
        // output — multiple of 64
        function hmac_finish ( offset, length, output ) {
            offset = offset|0;
            length = length|0;
            output = output|0;

            var t0h = 0, t0l = 0, t1h = 0, t1l = 0, t2h = 0, t2l = 0, t3h = 0, t3l = 0,
                t4h = 0, t4l = 0, t5h = 0, t5l = 0, t6h = 0, t6l = 0, t7h = 0, t7l = 0,
                hashed = 0;

            if ( offset & 127 )
                return -1;

            if ( ~output )
                if ( output & 63 )
                    return -1;

            hashed = finish( offset, length, -1 )|0;
            t0h = H0h;
            t0l = H0l;
            t1h = H1h;
            t1l = H1l;
            t2h = H2h;
            t2l = H2l;
            t3h = H3h;
            t3l = H3l;
            t4h = H4h;
            t4l = H4l;
            t5h = H5h;
            t5l = H5l;
            t6h = H6h;
            t6l = H6l;
            t7h = H7h;
            t7l = H7l;

            _hmac_opad();
            _core( t0h, t0l, t1h, t1l, t2h, t2l, t3h, t3l, t4h, t4l, t5h, t5l, t6h, t6l, t7h, t7l, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1536 );

            if ( ~output )
                _state_to_heap(output);

            return hashed|0;
        }

        // salt is assumed to be already processed
        // offset — multiple of 128
        // output — multiple of 64
        function pbkdf2_generate_block ( offset, length, block, count, output ) {
            offset = offset|0;
            length = length|0;
            block = block|0;
            count = count|0;
            output = output|0;

            var h0h = 0, h0l = 0, h1h = 0, h1l = 0, h2h = 0, h2l = 0, h3h = 0, h3l = 0,
                h4h = 0, h4l = 0, h5h = 0, h5l = 0, h6h = 0, h6l = 0, h7h = 0, h7l = 0,
                t0h = 0, t0l = 0, t1h = 0, t1l = 0, t2h = 0, t2l = 0, t3h = 0, t3l = 0,
                t4h = 0, t4l = 0, t5h = 0, t5l = 0, t6h = 0, t6l = 0, t7h = 0, t7l = 0;

            if ( offset & 127 )
                return -1;

            if ( ~output )
                if ( output & 63 )
                    return -1;

            // pad block number into heap
            // FIXME probable OOB write
            HEAP[(offset+length)|0]   = block>>>24;
            HEAP[(offset+length+1)|0] = block>>>16&255;
            HEAP[(offset+length+2)|0] = block>>>8&255;
            HEAP[(offset+length+3)|0] = block&255;

            // finish first iteration
            hmac_finish( offset, (length+4)|0, -1 )|0;

            h0h = t0h = H0h;
            h0l = t0l = H0l;
            h1h = t1h = H1h;
            h1l = t1l = H1l;
            h2h = t2h = H2h;
            h2l = t2l = H2l;
            h3h = t3h = H3h;
            h3l = t3l = H3l;
            h4h = t4h = H4h;
            h4l = t4l = H4l;
            h5h = t5h = H5h;
            h5l = t5l = H5l;
            h6h = t6h = H6h;
            h6l = t6l = H6l;
            h7h = t7h = H7h;
            h7l = t7l = H7l;

            count = (count-1)|0;

            // perform the rest iterations
            while ( (count|0) > 0 ) {
                hmac_reset();
                _core( t0h, t0l, t1h, t1l, t2h, t2l, t3h, t3l, t4h, t4l, t5h, t5l, t6h, t6l, t7h, t7l, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1536 );

                t0h = H0h;
                t0l = H0l;
                t1h = H1h;
                t1l = H1l;
                t2h = H2h;
                t2l = H2l;
                t3h = H3h;
                t3l = H3l;
                t4h = H4h;
                t4l = H4l;
                t5h = H5h;
                t5l = H5l;
                t6h = H6h;
                t6l = H6l;
                t7h = H7h;
                t7l = H7l;

                _hmac_opad();
                _core( t0h, t0l, t1h, t1l, t2h, t2l, t3h, t3l, t4h, t4l, t5h, t5l, t6h, t6l, t7h, t7l, 0x80000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1536 );

                t0h = H0h;
                t0l = H0l;
                t1h = H1h;
                t1l = H1l;
                t2h = H2h;
                t2l = H2l;
                t3h = H3h;
                t3l = H3l;
                t4h = H4h;
                t4l = H4l;
                t5h = H5h;
                t5l = H5l;
                t6h = H6h;
                t6l = H6l;
                t7h = H7h;
                t7l = H7l;

                h0h = h0h ^ H0h;
                h0l = h0l ^ H0l;
                h1h = h1h ^ H1h;
                h1l = h1l ^ H1l;
                h2h = h2h ^ H2h;
                h2l = h2l ^ H2l;
                h3h = h3h ^ H3h;
                h3l = h3l ^ H3l;
                h4h = h4h ^ H4h;
                h4l = h4l ^ H4l;
                h5h = h5h ^ H5h;
                h5l = h5l ^ H5l;
                h6h = h6h ^ H6h;
                h6l = h6l ^ H6l;
                h7h = h7h ^ H7h;
                h7l = h7l ^ H7l;

                count = (count-1)|0;
            }

            H0h = h0h;
            H0l = h0l;
            H1h = h1h;
            H1l = h1l;
            H2h = h2h;
            H2l = h2l;
            H3h = h3h;
            H3l = h3l;
            H4h = h4h;
            H4l = h4l;
            H5h = h5h;
            H5l = h5l;
            H6h = h6h;
            H6l = h6l;
            H7h = h7h;
            H7l = h7l;

            if ( ~output )
                _state_to_heap(output);

            return 0;
        }

        return {
          // SHA512
          reset: reset,
          init: init,
          process: process,
          finish: finish,

          // HMAC-SHA512
          hmac_reset: hmac_reset,
          hmac_init: hmac_init,
          hmac_finish: hmac_finish,

          // PBKDF2-HMAC-SHA512
          pbkdf2_generate_block: pbkdf2_generate_block
        }
    };

    var __extends$4 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var _sha512_block_size = 128;
    var _sha512_hash_size = 64;
    var Sha512 = /** @class */ (function (_super) {
        __extends$4(Sha512, _super);
        function Sha512() {
            var _this = _super.call(this) || this;
            _this.NAME = 'sha512';
            _this.BLOCK_SIZE = _sha512_block_size;
            _this.HASH_SIZE = _sha512_hash_size;
            _this.heap = _heap_init();
            _this.asm = sha512_asm({ Uint8Array: Uint8Array }, null, _this.heap.buffer);
            _this.reset();
            return _this;
        }
        Sha512.NAME = 'sha512';
        return Sha512;
    }(Hash));

    var Hmac = /** @class */ (function () {
        function Hmac(hash, password, verify) {
            if (!hash.HASH_SIZE)
                throw new SyntaxError("option 'hash' supplied doesn't seem to be a valid hash function");
            this.hash = hash;
            this.BLOCK_SIZE = this.hash.BLOCK_SIZE;
            this.HMAC_SIZE = this.hash.HASH_SIZE;
            this.result = null;
            this.key = _hmac_key(this.hash, password);
            var ipad = new Uint8Array(this.key);
            for (var i = 0; i < ipad.length; ++i)
                ipad[i] ^= 0x36;
            this.hash.reset().process(ipad);
            if (verify !== undefined) {
                this._hmac_init_verify(verify);
            }
            else {
                this.verify = null;
            }
        }
        Hmac.prototype.process = function (data) {
            if (this.result !== null)
                throw new IllegalStateError('state must be reset before processing new data');
            this.hash.process(data);
            return this;
        };
        Hmac.prototype.finish = function () {
            if (this.result !== null)
                throw new IllegalStateError('state must be reset before processing new data');
            var inner_result = this.hash.finish().result;
            var opad = new Uint8Array(this.key);
            for (var i = 0; i < opad.length; ++i)
                opad[i] ^= 0x5c;
            var verify = this.verify;
            var result = this.hash
                .reset()
                .process(opad)
                .process(inner_result)
                .finish().result;
            if (verify) {
                if (verify.length === result.length) {
                    var diff = 0;
                    for (var i = 0; i < verify.length; i++) {
                        diff |= verify[i] ^ result[i];
                    }
                    if (diff !== 0)
                        throw new Error("HMAC verification failed, hash value doesn't match");
                }
                else {
                    throw new Error("HMAC verification failed, lengths doesn't match");
                }
            }
            this.result = result;
            return this;
        };
        Hmac.prototype._hmac_init_verify = function (verify) {
            if (verify.length !== this.HMAC_SIZE)
                throw new IllegalArgumentError('illegal verification tag size');
            this.verify = verify;
        };
        return Hmac;
    }());
    function _hmac_key(hash, password) {
        var key = new Uint8Array(hash.BLOCK_SIZE);
        if (password.length > hash.BLOCK_SIZE) {
            key.set(hash
                .reset()
                .process(password)
                .finish().result);
        }
        else {
            key.set(password);
        }
        return key;
    }

    var __extends$5 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var HmacSha1 = /** @class */ (function (_super) {
        __extends$5(HmacSha1, _super);
        function HmacSha1(password, verify) {
            var _this = this;
            var hash = new Sha1();
            // Calculate ipad, init the underlying engine, calculate this.key
            _this = _super.call(this, hash, password, verify) || this;
            _this.reset();
            if (verify !== undefined) {
                _this._hmac_init_verify(verify);
            }
            else {
                _this.verify = null;
            }
            return _this;
        }
        HmacSha1.prototype.reset = function () {
            this.result = null;
            var key = this.key;
            this.hash
                .reset()
                .asm.hmac_init((key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3], (key[4] << 24) | (key[5] << 16) | (key[6] << 8) | key[7], (key[8] << 24) | (key[9] << 16) | (key[10] << 8) | key[11], (key[12] << 24) | (key[13] << 16) | (key[14] << 8) | key[15], (key[16] << 24) | (key[17] << 16) | (key[18] << 8) | key[19], (key[20] << 24) | (key[21] << 16) | (key[22] << 8) | key[23], (key[24] << 24) | (key[25] << 16) | (key[26] << 8) | key[27], (key[28] << 24) | (key[29] << 16) | (key[30] << 8) | key[31], (key[32] << 24) | (key[33] << 16) | (key[34] << 8) | key[35], (key[36] << 24) | (key[37] << 16) | (key[38] << 8) | key[39], (key[40] << 24) | (key[41] << 16) | (key[42] << 8) | key[43], (key[44] << 24) | (key[45] << 16) | (key[46] << 8) | key[47], (key[48] << 24) | (key[49] << 16) | (key[50] << 8) | key[51], (key[52] << 24) | (key[53] << 16) | (key[54] << 8) | key[55], (key[56] << 24) | (key[57] << 16) | (key[58] << 8) | key[59], (key[60] << 24) | (key[61] << 16) | (key[62] << 8) | key[63]);
            return this;
        };
        HmacSha1.prototype.finish = function () {
            if (this.result !== null)
                throw new IllegalStateError('state must be reset before processing new data');
            var hash = this.hash;
            var asm = this.hash.asm;
            var heap = this.hash.heap;
            asm.hmac_finish(hash.pos, hash.len, 0);
            var verify = this.verify;
            var result = new Uint8Array(_sha1_hash_size);
            result.set(heap.subarray(0, _sha1_hash_size));
            if (verify) {
                if (verify.length === result.length) {
                    var diff = 0;
                    for (var i = 0; i < verify.length; i++) {
                        diff |= verify[i] ^ result[i];
                    }
                    if (diff !== 0)
                        throw new Error("HMAC verification failed, hash value doesn't match");
                }
                else {
                    throw new Error("HMAC verification failed, lengths doesn't match");
                }
            }
            else {
                this.result = result;
            }
            return this;
        };
        return HmacSha1;
    }(Hmac));

    var __extends$6 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var HmacSha256 = /** @class */ (function (_super) {
        __extends$6(HmacSha256, _super);
        function HmacSha256(password, verify) {
            var _this = this;
            var hash = new Sha256();
            // Calculate ipad, init the underlying engine, calculate this.key
            _this = _super.call(this, hash, password, verify) || this;
            _this.reset();
            if (verify !== undefined) {
                _this._hmac_init_verify(verify);
            }
            else {
                _this.verify = null;
            }
            return _this;
        }
        HmacSha256.prototype.reset = function () {
            var key = this.key;
            this.hash
                .reset()
                .asm.hmac_init((key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3], (key[4] << 24) | (key[5] << 16) | (key[6] << 8) | key[7], (key[8] << 24) | (key[9] << 16) | (key[10] << 8) | key[11], (key[12] << 24) | (key[13] << 16) | (key[14] << 8) | key[15], (key[16] << 24) | (key[17] << 16) | (key[18] << 8) | key[19], (key[20] << 24) | (key[21] << 16) | (key[22] << 8) | key[23], (key[24] << 24) | (key[25] << 16) | (key[26] << 8) | key[27], (key[28] << 24) | (key[29] << 16) | (key[30] << 8) | key[31], (key[32] << 24) | (key[33] << 16) | (key[34] << 8) | key[35], (key[36] << 24) | (key[37] << 16) | (key[38] << 8) | key[39], (key[40] << 24) | (key[41] << 16) | (key[42] << 8) | key[43], (key[44] << 24) | (key[45] << 16) | (key[46] << 8) | key[47], (key[48] << 24) | (key[49] << 16) | (key[50] << 8) | key[51], (key[52] << 24) | (key[53] << 16) | (key[54] << 8) | key[55], (key[56] << 24) | (key[57] << 16) | (key[58] << 8) | key[59], (key[60] << 24) | (key[61] << 16) | (key[62] << 8) | key[63]);
            return this;
        };
        HmacSha256.prototype.finish = function () {
            if (this.key === null)
                throw new IllegalStateError('no key is associated with the instance');
            if (this.result !== null)
                throw new IllegalStateError('state must be reset before processing new data');
            var hash = this.hash;
            var asm = this.hash.asm;
            var heap = this.hash.heap;
            asm.hmac_finish(hash.pos, hash.len, 0);
            var verify = this.verify;
            var result = new Uint8Array(_sha256_hash_size);
            result.set(heap.subarray(0, _sha256_hash_size));
            if (verify) {
                if (verify.length === result.length) {
                    var diff = 0;
                    for (var i = 0; i < verify.length; i++) {
                        diff |= verify[i] ^ result[i];
                    }
                    if (diff !== 0)
                        throw new Error("HMAC verification failed, hash value doesn't match");
                }
                else {
                    throw new Error("HMAC verification failed, lengths doesn't match");
                }
            }
            else {
                this.result = result;
            }
            return this;
        };
        return HmacSha256;
    }(Hmac));

    var __extends$7 = (undefined && undefined.__extends) || (function () {
        var extendStatics = function (d, b) {
            extendStatics = Object.setPrototypeOf ||
                ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
                function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
            return extendStatics(d, b);
        };
        return function (d, b) {
            extendStatics(d, b);
            function __() { this.constructor = d; }
            d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
        };
    })();
    var HmacSha512 = /** @class */ (function (_super) {
        __extends$7(HmacSha512, _super);
        function HmacSha512(password, verify) {
            var _this = this;
            var hash = new Sha512();
            // Calculate ipad, init the underlying engine, calculate this.key
            _this = _super.call(this, hash, password, verify) || this;
            _this.reset();
            if (verify !== undefined) {
                _this._hmac_init_verify(verify);
            }
            else {
                _this.verify = null;
            }
            return _this;
        }
        HmacSha512.prototype.reset = function () {
            var key = this.key;
            this.hash
                .reset()
                .asm.hmac_init((key[0] << 24) | (key[1] << 16) | (key[2] << 8) | key[3], (key[4] << 24) | (key[5] << 16) | (key[6] << 8) | key[7], (key[8] << 24) | (key[9] << 16) | (key[10] << 8) | key[11], (key[12] << 24) | (key[13] << 16) | (key[14] << 8) | key[15], (key[16] << 24) | (key[17] << 16) | (key[18] << 8) | key[19], (key[20] << 24) | (key[21] << 16) | (key[22] << 8) | key[23], (key[24] << 24) | (key[25] << 16) | (key[26] << 8) | key[27], (key[28] << 24) | (key[29] << 16) | (key[30] << 8) | key[31], (key[32] << 24) | (key[33] << 16) | (key[34] << 8) | key[35], (key[36] << 24) | (key[37] << 16) | (key[38] << 8) | key[39], (key[40] << 24) | (key[41] << 16) | (key[42] << 8) | key[43], (key[44] << 24) | (key[45] << 16) | (key[46] << 8) | key[47], (key[48] << 24) | (key[49] << 16) | (key[50] << 8) | key[51], (key[52] << 24) | (key[53] << 16) | (key[54] << 8) | key[55], (key[56] << 24) | (key[57] << 16) | (key[58] << 8) | key[59], (key[60] << 24) | (key[61] << 16) | (key[62] << 8) | key[63], (key[64] << 24) | (key[65] << 16) | (key[66] << 8) | key[67], (key[68] << 24) | (key[69] << 16) | (key[70] << 8) | key[71], (key[72] << 24) | (key[73] << 16) | (key[74] << 8) | key[75], (key[76] << 24) | (key[77] << 16) | (key[78] << 8) | key[79], (key[80] << 24) | (key[81] << 16) | (key[82] << 8) | key[83], (key[84] << 24) | (key[85] << 16) | (key[86] << 8) | key[87], (key[88] << 24) | (key[89] << 16) | (key[90] << 8) | key[91], (key[92] << 24) | (key[93] << 16) | (key[94] << 8) | key[95], (key[96] << 24) | (key[97] << 16) | (key[98] << 8) | key[99], (key[100] << 24) | (key[101] << 16) | (key[102] << 8) | key[103], (key[104] << 24) | (key[105] << 16) | (key[106] << 8) | key[107], (key[108] << 24) | (key[109] << 16) | (key[110] << 8) | key[111], (key[112] << 24) | (key[113] << 16) | (key[114] << 8) | key[115], (key[116] << 24) | (key[117] << 16) | (key[118] << 8) | key[119], (key[120] << 24) | (key[121] << 16) | (key[122] << 8) | key[123], (key[124] << 24) | (key[125] << 16) | (key[126] << 8) | key[127]);
            return this;
        };
        HmacSha512.prototype.finish = function () {
            if (this.key === null)
                throw new IllegalStateError('no key is associated with the instance');
            if (this.result !== null)
                throw new IllegalStateError('state must be reset before processing new data');
            var hash = this.hash;
            var asm = this.hash.asm;
            var heap = this.hash.heap;
            asm.hmac_finish(hash.pos, hash.len, 0);
            var verify = this.verify;
            var result = new Uint8Array(_sha512_hash_size);
            result.set(heap.subarray(0, _sha512_hash_size));
            if (verify) {
                if (verify.length === result.length) {
                    var diff = 0;
                    for (var i = 0; i < verify.length; i++) {
                        diff |= verify[i] ^ result[i];
                    }
                    if (diff !== 0)
                        throw new Error("HMAC verification failed, hash value doesn't match");
                }
                else {
                    throw new Error("HMAC verification failed, lengths doesn't match");
                }
            }
            else {
                this.result = result;
            }
            return this;
        };
        return HmacSha512;
    }(Hmac));

    function pbkdf2core(hmac, salt, length, count) {
        var result = new Uint8Array(length);
        var blocks = Math.ceil(length / hmac.HMAC_SIZE);
        for (var i = 1; i <= blocks; ++i) {
            var j = (i - 1) * hmac.HMAC_SIZE;
            var l = (i < blocks ? 0 : length % hmac.HMAC_SIZE) || hmac.HMAC_SIZE;
            hmac.reset().process(salt);
            hmac.hash.asm.pbkdf2_generate_block(hmac.hash.pos, hmac.hash.len, i, count, 0);
            result.set(hmac.hash.heap.subarray(0, l), j);
        }
        return result;
    }

    function Pbkdf2HmacSha1(password, salt, count, length) {
        var hmac = new HmacSha1(password);
        return pbkdf2core(hmac, salt, length, count);
    }

    function Pbkdf2HmacSha256(password, salt, count, length) {
        var hmac = new HmacSha256(password);
        return pbkdf2core(hmac, salt, length, count);
    }

    function Pbkdf2HmacSha512(password, salt, count, length) {
        var hmac = new HmacSha512(password);
        return pbkdf2core(hmac, salt, length, count);
    }

    var RSA = /** @class */ (function () {
        function RSA(key) {
            var l = key.length;
            if (l !== 2 && l !== 3 && l !== 8)
                throw new SyntaxError('unexpected key type');
            var k0 = new Modulus(new BigNumber(key[0]));
            var k1 = new BigNumber(key[1]);
            this.key = {
                0: k0,
                1: k1,
            };
            if (l > 2) {
                this.key[2] = new BigNumber(key[2]);
            }
            if (l > 3) {
                this.key[3] = new Modulus(new BigNumber(key[3]));
                this.key[4] = new Modulus(new BigNumber(key[4]));
                this.key[5] = new BigNumber(key[5]);
                this.key[6] = new BigNumber(key[6]);
                this.key[7] = new BigNumber(key[7]);
            }
        }
        RSA.prototype.encrypt = function (msg) {
            if (!this.key)
                throw new IllegalStateError('no key is associated with the instance');
            if (this.key[0].compare(msg) <= 0)
                throw new RangeError('data too large');
            var m = this.key[0];
            var e = this.key[1];
            var result = m.power(msg, e).toBytes();
            var bytelen = (m.bitLength + 7) >> 3;
            if (result.length < bytelen) {
                var r = new Uint8Array(bytelen);
                r.set(result, bytelen - result.length);
                result = r;
            }
            this.result = result;
            return this;
        };
        RSA.prototype.decrypt = function (msg) {
            if (this.key[0].compare(msg) <= 0)
                throw new RangeError('data too large');
            var result;
            var m;
            if (this.key[3] !== undefined) {
                m = this.key[0];
                var p = this.key[3];
                var q = this.key[4];
                var dp = this.key[5];
                var dq = this.key[6];
                var u = this.key[7];
                var x = p.power(msg, dp);
                var y = q.power(msg, dq);
                var t = x.subtract(y);
                while (t.sign < 0)
                    t = t.add(p);
                var h = p.reduce(u.multiply(t));
                result = h
                    .multiply(q)
                    .add(y)
                    .clamp(m.bitLength)
                    .toBytes();
            }
            else {
                m = this.key[0];
                var d = this.key[2];
                result = m.power(msg, d).toBytes();
            }
            var bytelen = (m.bitLength + 7) >> 3;
            if (result.length < bytelen) {
                var r = new Uint8Array(bytelen);
                r.set(result, bytelen - result.length);
                result = r;
            }
            this.result = result;
            return this;
        };
        return RSA;
    }());

    var RSA_OAEP = /** @class */ (function () {
        function RSA_OAEP(key, hash, label) {
            this.rsa = new RSA(key);
            this.hash = hash;
            if (label !== undefined) {
                this.label = label.length > 0 ? label : null;
            }
            else {
                this.label = null;
            }
        }
        RSA_OAEP.prototype.encrypt = function (data, random) {
            var key_size = Math.ceil(this.rsa.key[0].bitLength / 8);
            var hash_size = this.hash.HASH_SIZE;
            var data_length = data.byteLength || data.length || 0;
            var ps_length = key_size - data_length - 2 * hash_size - 2;
            if (data_length > key_size - 2 * this.hash.HASH_SIZE - 2)
                throw new IllegalArgumentError('data too large');
            var message = new Uint8Array(key_size);
            var seed = message.subarray(1, hash_size + 1);
            var data_block = message.subarray(hash_size + 1);
            data_block.set(data, hash_size + ps_length + 1);
            data_block.set(this.hash.process(this.label || new Uint8Array(0)).finish().result, 0);
            data_block[hash_size + ps_length] = 1;
            if (random !== undefined) {
                if (seed.length !== random.length)
                    throw new IllegalArgumentError('random size must equal the hash size');
                seed.set(random);
            }
            else {
                getRandomValues(seed);
            }
            var data_block_mask = this.RSA_MGF1_generate(seed, data_block.length);
            for (var i = 0; i < data_block.length; i++)
                data_block[i] ^= data_block_mask[i];
            var seed_mask = this.RSA_MGF1_generate(data_block, seed.length);
            for (var i = 0; i < seed.length; i++)
                seed[i] ^= seed_mask[i];
            this.rsa.encrypt(new BigNumber(message));
            return new Uint8Array(this.rsa.result);
        };
        RSA_OAEP.prototype.decrypt = function (data) {
            if (!this.rsa.key)
                throw new IllegalStateError('no key is associated with the instance');
            var key_size = Math.ceil(this.rsa.key[0].bitLength / 8);
            var hash_size = this.hash.HASH_SIZE;
            var data_length = data.byteLength || data.length || 0;
            if (data_length !== key_size)
                throw new IllegalArgumentError('bad data');
            this.rsa.decrypt(new BigNumber(data));
            var z = this.rsa.result[0];
            var seed = this.rsa.result.subarray(1, hash_size + 1);
            var data_block = this.rsa.result.subarray(hash_size + 1);
            if (z !== 0)
                throw new SecurityError('decryption failed');
            var seed_mask = this.RSA_MGF1_generate(data_block, seed.length);
            for (var i = 0; i < seed.length; i++)
                seed[i] ^= seed_mask[i];
            var data_block_mask = this.RSA_MGF1_generate(seed, data_block.length);
            for (var i = 0; i < data_block.length; i++)
                data_block[i] ^= data_block_mask[i];
            var lhash = this.hash
                .reset()
                .process(this.label || new Uint8Array(0))
                .finish().result;
            for (var i = 0; i < hash_size; i++) {
                if (lhash[i] !== data_block[i])
                    throw new SecurityError('decryption failed');
            }
            var ps_end = hash_size;
            for (; ps_end < data_block.length; ps_end++) {
                var psz = data_block[ps_end];
                if (psz === 1)
                    break;
                if (psz !== 0)
                    throw new SecurityError('decryption failed');
            }
            if (ps_end === data_block.length)
                throw new SecurityError('decryption failed');
            this.rsa.result = data_block.subarray(ps_end + 1);
            return new Uint8Array(this.rsa.result);
        };
        RSA_OAEP.prototype.RSA_MGF1_generate = function (seed, length) {
            if (length === void 0) { length = 0; }
            var hash_size = this.hash.HASH_SIZE;
            //    if ( length > (hash_size * 0x100000000) )
            //        throw new IllegalArgumentError("mask length too large");
            var mask = new Uint8Array(length);
            var counter = new Uint8Array(4);
            var chunks = Math.ceil(length / hash_size);
            for (var i = 0; i < chunks; i++) {
                (counter[0] = i >>> 24), (counter[1] = (i >>> 16) & 255), (counter[2] = (i >>> 8) & 255), (counter[3] = i & 255);
                var submask = mask.subarray(i * hash_size);
                var chunk = this.hash
                    .reset()
                    .process(seed)
                    .process(counter)
                    .finish().result;
                if (chunk.length > submask.length)
                    chunk = chunk.subarray(0, submask.length);
                submask.set(chunk);
            }
            return mask;
        };
        return RSA_OAEP;
    }());
    var RSA_PSS = /** @class */ (function () {
        function RSA_PSS(key, hash, saltLength) {
            if (saltLength === void 0) { saltLength = 4; }
            this.rsa = new RSA(key);
            this.hash = hash;
            this.saltLength = saltLength;
            if (this.saltLength < 0)
                throw new TypeError('saltLength should be a non-negative number');
            if (this.rsa.key !== null &&
                Math.ceil((this.rsa.key[0].bitLength - 1) / 8) < this.hash.HASH_SIZE + this.saltLength + 2)
                throw new SyntaxError('saltLength is too large');
        }
        RSA_PSS.prototype.sign = function (data, random) {
            var key_bits = this.rsa.key[0].bitLength;
            var hash_size = this.hash.HASH_SIZE;
            var message_length = Math.ceil((key_bits - 1) / 8);
            var salt_length = this.saltLength;
            var ps_length = message_length - salt_length - hash_size - 2;
            var message = new Uint8Array(message_length);
            var h_block = message.subarray(message_length - hash_size - 1, message_length - 1);
            var d_block = message.subarray(0, message_length - hash_size - 1);
            var d_salt = d_block.subarray(ps_length + 1);
            var m_block = new Uint8Array(8 + hash_size + salt_length);
            var m_hash = m_block.subarray(8, 8 + hash_size);
            var m_salt = m_block.subarray(8 + hash_size);
            m_hash.set(this.hash.process(data).finish().result);
            if (salt_length > 0) {
                if (random !== undefined) {
                    if (m_salt.length !== random.length)
                        throw new IllegalArgumentError('random size must equal the salt size');
                    m_salt.set(random);
                }
                else {
                    getRandomValues(m_salt);
                }
            }
            d_block[ps_length] = 1;
            d_salt.set(m_salt);
            h_block.set(this.hash
                .reset()
                .process(m_block)
                .finish().result);
            var d_block_mask = this.RSA_MGF1_generate(h_block, d_block.length);
            for (var i = 0; i < d_block.length; i++)
                d_block[i] ^= d_block_mask[i];
            message[message_length - 1] = 0xbc;
            var zbits = 8 * message_length - key_bits + 1;
            if (zbits % 8)
                message[0] &= 0xff >>> zbits;
            this.rsa.decrypt(new BigNumber(message));
            return this.rsa.result;
        };
        RSA_PSS.prototype.verify = function (signature, data) {
            var key_bits = this.rsa.key[0].bitLength;
            var hash_size = this.hash.HASH_SIZE;
            var message_length = Math.ceil((key_bits - 1) / 8);
            var salt_length = this.saltLength;
            var ps_length = message_length - salt_length - hash_size - 2;
            this.rsa.encrypt(new BigNumber(signature));
            var message = this.rsa.result;
            if (message[message_length - 1] !== 0xbc)
                throw new SecurityError('bad signature');
            var h_block = message.subarray(message_length - hash_size - 1, message_length - 1);
            var d_block = message.subarray(0, message_length - hash_size - 1);
            var d_salt = d_block.subarray(ps_length + 1);
            var zbits = 8 * message_length - key_bits + 1;
            if (zbits % 8 && message[0] >>> (8 - zbits))
                throw new SecurityError('bad signature');
            var d_block_mask = this.RSA_MGF1_generate(h_block, d_block.length);
            for (var i = 0; i < d_block.length; i++)
                d_block[i] ^= d_block_mask[i];
            if (zbits % 8)
                message[0] &= 0xff >>> zbits;
            for (var i = 0; i < ps_length; i++) {
                if (d_block[i] !== 0)
                    throw new SecurityError('bad signature');
            }
            if (d_block[ps_length] !== 1)
                throw new SecurityError('bad signature');
            var m_block = new Uint8Array(8 + hash_size + salt_length);
            var m_hash = m_block.subarray(8, 8 + hash_size);
            var m_salt = m_block.subarray(8 + hash_size);
            m_hash.set(this.hash
                .reset()
                .process(data)
                .finish().result);
            m_salt.set(d_salt);
            var h_block_verify = this.hash
                .reset()
                .process(m_block)
                .finish().result;
            for (var i = 0; i < hash_size; i++) {
                if (h_block[i] !== h_block_verify[i])
                    throw new SecurityError('bad signature');
            }
        };
        RSA_PSS.prototype.RSA_MGF1_generate = function (seed, length) {
            if (length === void 0) { length = 0; }
            var hash_size = this.hash.HASH_SIZE;
            //    if ( length > (hash_size * 0x100000000) )
            //        throw new IllegalArgumentError("mask length too large");
            var mask = new Uint8Array(length);
            var counter = new Uint8Array(4);
            var chunks = Math.ceil(length / hash_size);
            for (var i = 0; i < chunks; i++) {
                (counter[0] = i >>> 24), (counter[1] = (i >>> 16) & 255), (counter[2] = (i >>> 8) & 255), (counter[3] = i & 255);
                var submask = mask.subarray(i * hash_size);
                var chunk = this.hash
                    .reset()
                    .process(seed)
                    .process(counter)
                    .finish().result;
                if (chunk.length > submask.length)
                    chunk = chunk.subarray(0, submask.length);
                submask.set(chunk);
            }
            return mask;
        };
        return RSA_PSS;
    }());
    var RSA_PKCS1_v1_5 = /** @class */ (function () {
        function RSA_PKCS1_v1_5(key, hash) {
            this.rsa = new RSA(key);
            this.hash = hash;
        }
        RSA_PKCS1_v1_5.prototype.sign = function (data) {
            if (!this.rsa.key) {
                throw new IllegalStateError('no key is associated with the instance');
            }
            var prefix = getHashPrefix(this.hash);
            var hash_size = this.hash.HASH_SIZE;
            var t_len = prefix.length + hash_size;
            var k = (this.rsa.key[0].bitLength + 7) >> 3;
            if (k < t_len + 11) {
                throw new Error('Message too long');
            }
            var m_hash = new Uint8Array(hash_size);
            m_hash.set(this.hash.process(data).finish().result);
            // EM = 0x00 || 0x01 || PS || 0x00 || T
            var em = new Uint8Array(k);
            var i = 0;
            em[i++] = 0; // 0x00
            em[i++] = 1; // 0x01
            // PS
            for (i; i < k - t_len - 1; i++) {
                em[i] = 0xff;
            }
            em[i++] = 0;
            em.set(prefix, i); // 0x00
            // T
            em.set(m_hash, em.length - hash_size);
            this.rsa.decrypt(new BigNumber(em));
            return this.rsa.result;
        };
        RSA_PKCS1_v1_5.prototype.verify = function (signature, data) {
            var prefix = getHashPrefix(this.hash);
            var hash_size = this.hash.HASH_SIZE;
            var t_len = prefix.length + hash_size;
            var k = (this.rsa.key[0].bitLength + 7) >> 3;
            if (k < t_len + 11) {
                throw new SecurityError('Bad signature');
            }
            this.rsa.encrypt(new BigNumber(signature));
            var m_hash = new Uint8Array(hash_size);
            m_hash.set(this.hash.process(data).finish().result);
            var res = 1;
            // EM = 0x00 || 0x01 || PS || 0x00 || T
            var decryptedSignature = this.rsa.result;
            var i = 0;
            res &= decryptedSignature[i++] === 0 ? 1 : 0; // 0x00
            res &= decryptedSignature[i++] === 1 ? 1 : 0; // 0x01
            // PS
            for (i; i < k - t_len - 1; i++) {
                res &= decryptedSignature[i] === 0xff ? 1 : 0;
            }
            res &= decryptedSignature[i++] === 0 ? 1 : 0; // 0x00
            // T
            var j = 0;
            var n = i + prefix.length;
            // prefix
            for (i; i < n; i++) {
                res &= decryptedSignature[i] === prefix[j++] ? 1 : 0;
            }
            j = 0;
            n = i + m_hash.length;
            // hash
            for (i; i < n; i++) {
                res &= decryptedSignature[i] === m_hash[j++] ? 1 : 0;
            }
            if (!res) {
                throw new SecurityError('Bad signature');
            }
        };
        return RSA_PKCS1_v1_5;
    }());
    var HASH_PREFIXES = {
        sha1: new Uint8Array([0x30, 0x21, 0x30, 0x09, 0x06, 0x05, 0x2b, 0x0e, 0x03, 0x02, 0x1a, 0x05, 0x00, 0x04, 0x14]),
        sha256: new Uint8Array([
            0x30,
            0x31,
            0x30,
            0x0d,
            0x06,
            0x09,
            0x60,
            0x86,
            0x48,
            0x01,
            0x65,
            0x03,
            0x04,
            0x02,
            0x01,
            0x05,
            0x00,
            0x04,
            0x20,
        ]),
        sha384: new Uint8Array([
            0x30,
            0x41,
            0x30,
            0x0d,
            0x06,
            0x09,
            0x60,
            0x86,
            0x48,
            0x01,
            0x65,
            0x03,
            0x04,
            0x02,
            0x02,
            0x05,
            0x00,
            0x04,
            0x30,
        ]),
        sha512: new Uint8Array([
            0x30,
            0x51,
            0x30,
            0x0d,
            0x06,
            0x09,
            0x60,
            0x86,
            0x48,
            0x01,
            0x65,
            0x03,
            0x04,
            0x02,
            0x03,
            0x05,
            0x00,
            0x04,
            0x40,
        ]),
    };
    function getHashPrefix(hash) {
        var prefix = HASH_PREFIXES[hash.NAME];
        if (!prefix) {
            throw new Error("Cannot get hash prefix for hash algorithm '" + hash.NAME + "'");
        }
        return prefix;
    }

    exports.string_to_bytes = string_to_bytes;
    exports.hex_to_bytes = hex_to_bytes;
    exports.base64_to_bytes = base64_to_bytes;
    exports.bytes_to_string = bytes_to_string;
    exports.bytes_to_hex = bytes_to_hex;
    exports.bytes_to_base64 = bytes_to_base64;
    exports.IllegalStateError = IllegalStateError;
    exports.IllegalArgumentError = IllegalArgumentError;
    exports.SecurityError = SecurityError;
    exports.AES_CBC = AES_CBC;
    exports.AES_CCM = AES_CCM;
    exports.AES_CFB = AES_CFB;
    exports.AES_CMAC = AES_CMAC;
    exports.AES_CTR = AES_CTR;
    exports.AES_ECB = AES_ECB;
    exports.AES_GCM = AES_GCM;
    exports.AES_OFB = AES_OFB;
    exports.BigNumber = BigNumber;
    exports.Modulus = Modulus;
    exports.Sha1 = Sha1;
    exports.Sha256 = Sha256;
    exports.Sha512 = Sha512;
    exports.HmacSha1 = HmacSha1;
    exports.HmacSha256 = HmacSha256;
    exports.HmacSha512 = HmacSha512;
    exports.Pbkdf2HmacSha1 = Pbkdf2HmacSha1;
    exports.Pbkdf2HmacSha256 = Pbkdf2HmacSha256;
    exports.Pbkdf2HmacSha512 = Pbkdf2HmacSha512;
    exports.RSA_OAEP = RSA_OAEP;
    exports.RSA_PKCS1_v1_5 = RSA_PKCS1_v1_5;
    exports.RSA_PSS = RSA_PSS;
    exports.RSA = RSA;

    return exports;

}({}));


if(!('filesender' in window)) window.filesender = {};
window.filesender.asmcryptoR = {};

console.log('asmCrypto1');
console.log(asmCrypto);
console.log('asmCrypto.json ' + JSON.stringify(asmCrypto));

window.filesender.asmcryptoR.Pbkdf2HmacSha256 = asmCrypto.Pbkdf2HmacSha256;
//asmCrypto(window.filesender.asmcryptoR);


    
